/** * If values are passed in, replaces any cached cursor with one containing new values, and then * closes the previously cached one (if any, and if not in use) If values are not passed in, * removes the row from cache If the row was locked, unlock it * * @param id the id of the row * @param values new ContentValues for the row (or null if row should simply be removed) * @param wasLocked whether or not the row was locked; if so, the lock will be removed */ private void unlockImpl(String id, ContentValues values, boolean wasLocked) { Cursor c = get(id); if (c != null) { if (MailActivityEmail.DEBUG && DEBUG_CACHE) { LogUtils.d(mLogTag, "=========== Unlocking cache for: " + id); } if (values != null && !sLockCache) { MatrixCursor cursor = getMatrixCursor(id, mBaseProjection, values); if (cursor != null) { if (MailActivityEmail.DEBUG && DEBUG_CACHE) { LogUtils.d(mLogTag, "=========== Recaching with new values: " + id); } cursor.moveToFirst(); mLruCache.put(id, cursor); } else { mLruCache.remove(id); } } else { mLruCache.remove(id); } // If there are no cursors using the old cached cursor, close it if (!sActiveCursors.contains(c)) { c.close(); } } if (wasLocked) { mLockMap.subtract(id); } }
/** * Try to continue chat conversation * * @param continueChat the intent to continue the chat conversation * @param chatId the chat ID * @return the unique ID to be used to create the pending intent if chat conversation is not on * foreground or null if continuing the conversation succeeded */ public Integer tryContinueChatConversation(Intent continueChat, String chatId) { if (mForegroundInfo.isConversationOnForeground(chatId)) { /* * Do not display notification if activity is on foreground for this chatId */ Integer pendingIntentId = mPendingNotificationIdCache.get(chatId); if (pendingIntentId != null) { mPendingNotificationIdCache.remove(chatId); mNotifManager.cancel(pendingIntentId); } /* This will trigger onNewIntent for the target activity */ mCtx.startActivity(continueChat); return null; } Integer uniquePendingIntentId = mPendingNotificationIdCache.get(chatId); if (uniquePendingIntentId == null) { /* * If the PendingIntent has the same operation, action, data, categories, components, * and flags it will be replaced. Invitation should be notified individually so we use a * random generator to provide a unique request code and reuse it for the notification. */ uniquePendingIntentId = Utils.getUniqueIdForPendingIntent(); mPendingNotificationIdCache.put(chatId, uniquePendingIntentId); } return uniquePendingIntentId; }
/** Remove a bitmap from the LRU cache. */ protected Bitmap removeBitmapFromMemCache(String key) { if (key == null) { return null; } if (key.startsWith(RecentPanelView.TASK_PACKAGE_IDENTIFIER)) { mKeys.remove(key); } return mMemoryCache.remove(key); }
/** * Creates an empty placeholder. * * @param size the size of the placeholder in pixels. * @return A new URI used to reference this placeholder */ @Nonnull public static Uri addEmptyPlaceholder(@Nonnull Size size) { Uri uri = generateUniquePlaceholderUri(); sSessionsToSizes.put(uri, new Point(size.getWidth(), size.getHeight())); sSessionsToPlaceholderBitmap.remove(uri); Integer currentVersion = sSessionsToPlaceholderVersions.get(uri); sSessionsToPlaceholderVersions.put(uri, currentVersion == null ? 0 : currentVersion + 1); return uri; }
public void removeCache(String url) { Log.v("마이볼리 캐쉬 사이즈", String.valueOf(cache.size())); Log.v("마이볼리 캐쉬", String.valueOf(cache)); Log.v("url name", url); if (cache.remove(url) == null) { Log.v("url", "null"); } Log.v("마이볼리 캐쉬 사이즈", String.valueOf(cache.size())); Log.v("마이볼리 캐쉬", String.valueOf(cache)); }
public static Bitmap removeBitmap(String key) { return sMemoryCache.remove(key); }
public void remove(String key) { if (mLruCache != null) { mLruCache.remove(key); } }
/** Remove a placeholder from in memory storage. */ public static void removePlaceholder(Uri uri) { sSessionsToSizes.remove(uri); sSessionsToPlaceholderBitmap.remove(uri); sSessionsToPlaceholderVersions.remove(uri); }
/** * Releases resources for an archive with the specified document ID. It will block until all * operations on the archive are finished. If not opened, the method does nothing. * * <p>Calling this method is optional. The helper automatically closes the least recently used * archives if too many archives are opened. * * @param archiveDocumentId ID of the archive file. */ public void closeArchive(String documentId) { synchronized (mArchives) { mArchives.remove(documentId); } }