Java CacheKey类代码示例

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
public void init(
    Resources resources,
    DeferredReleaser deferredReleaser,
    DrawableFactory animatedDrawableFactory,
    Executor uiThreadExecutor,
    MemoryCache<CacheKey, CloseableImage> memoryCache,
    @Nullable ImmutableList<DrawableFactory> drawableFactories,
    @Nullable Supplier<Boolean> debugOverlayEnabledSupplier) {
  mResources = resources;
  mDeferredReleaser = deferredReleaser;
  mAnimatedDrawableFactory = animatedDrawableFactory;
  mUiThreadExecutor = uiThreadExecutor;
  mMemoryCache = memoryCache;
  mDrawableFactories = drawableFactories;
  mDebugOverlayEnabledSupplier = debugOverlayEnabledSupplier;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
public PipelineDraweeController newController(
    Supplier<DataSource<CloseableReference<CloseableImage>>> dataSourceSupplier,
    String id,
    CacheKey cacheKey,
    Object callerContext,
    @Nullable ImmutableList<DrawableFactory> customDrawableFactories) {
  Preconditions.checkState(mResources != null, "init() not called");
  // Field values passed as arguments so that any subclass of PipelineDraweeControllerFactory
  // can simply override internalCreateController() and return a custom Drawee controller
  PipelineDraweeController controller = internalCreateController(
      mResources,
      mDeferredReleaser,
      mAnimatedDrawableFactory,
      mUiThreadExecutor,
      mMemoryCache,
      mDrawableFactories,
      customDrawableFactories,
      dataSourceSupplier,
      id,
      cacheKey,
      callerContext);
  if (mDebugOverlayEnabledSupplier != null) {
    controller.setDrawDebugOverlay(mDebugOverlayEnabledSupplier.get());
  }
  return controller;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
protected PipelineDraweeController internalCreateController(
    Resources resources,
    DeferredReleaser deferredReleaser,
    DrawableFactory animatedDrawableFactory,
    Executor uiThreadExecutor,
    MemoryCache<CacheKey, CloseableImage> memoryCache,
    @Nullable ImmutableList<DrawableFactory> globalDrawableFactories,
    @Nullable ImmutableList<DrawableFactory> customDrawableFactories,
    Supplier<DataSource<CloseableReference<CloseableImage>>> dataSourceSupplier,
    String id,
    CacheKey cacheKey,
    Object callerContext) {
  PipelineDraweeController controller = new PipelineDraweeController(
      resources,
      deferredReleaser,
      animatedDrawableFactory,
      uiThreadExecutor,
      memoryCache,
      dataSourceSupplier,
      id,
      cacheKey,
      callerContext,
      globalDrawableFactories);
  controller.setCustomDrawableFactories(customDrawableFactories);
  return controller;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
/**
 * Writes to disk cache
 * @throws IOException
 */
private void writeToDiskCache(
    final CacheKey key,
    final EncodedImage encodedImage) {
  FLog.v(TAG, "About to write to disk-cache for key %s", key.getUriString());
  try {
    mFileCache.insert(
        key, new WriterCallback() {
          @Override
          public void write(OutputStream os) throws IOException {
            mPooledByteStreams.copy(encodedImage.getInputStream(), os);
          }
        }
    );
    FLog.v(TAG, "Successful disk-cache write for key %s", key.getUriString());
  } catch (IOException ioe) {
    // Log failure
    // TODO: 3697790
    FLog.w(TAG, ioe, "Failed to write to disk-cache for key %s", key.getUriString());
  }
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
public ExperimentalBitmapAnimationDrawableFactory(
    AnimatedDrawableBackendProvider animatedDrawableBackendProvider,
    ScheduledExecutorService scheduledExecutorServiceForUiThread,
    ExecutorService executorServiceForFramePreparing,
    MonotonicClock monotonicClock,
    PlatformBitmapFactory platformBitmapFactory,
    CountingMemoryCache<CacheKey, CloseableImage> backingCache,
    Supplier<Integer> cachingStrategySupplier,
    Supplier<Integer> numberOfFramesToPrepareSupplier) {
  mAnimatedDrawableBackendProvider = animatedDrawableBackendProvider;
  mScheduledExecutorServiceForUiThread = scheduledExecutorServiceForUiThread;
  mExecutorServiceForFramePreparing = executorServiceForFramePreparing;
  mMonotonicClock = monotonicClock;
  mPlatformBitmapFactory = platformBitmapFactory;
  mBackingCache = backingCache;
  mCachingStrategySupplier = cachingStrategySupplier;
  mNumberOfFramesToPrepareSupplier = numberOfFramesToPrepareSupplier;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  MemoryCacheParams params = new MemoryCacheParams(
      4 * ByteConstants.MB,
      256,
      Integer.MAX_VALUE,
      Integer.MAX_VALUE,
      Integer.MAX_VALUE);
  when(mMemoryCacheParamsSupplier.get()).thenReturn(params);
  CountingMemoryCache<CacheKey, CloseableImage> countingMemoryCache =
      BitmapCountingMemoryCacheFactory.get(
          mMemoryCacheParamsSupplier,
          mMemoryTrimmableRegistry,
          mPlatformBitmapFactory,
          true);
  mCacheKey = new SimpleCacheKey("key");
  mAnimatedFrameCache = new AnimatedFrameCache(mCacheKey, countingMemoryCache);
  mFrame1 = CloseableReference.of(mock(CloseableImage.class));
  mFrame2 = CloseableReference.of(mock(CloseableImage.class));
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
public static AnimatedFactory getAnimatedFactory(
    PlatformBitmapFactory platformBitmapFactory,
    ExecutorSupplier executorSupplier,
    CountingMemoryCache<CacheKey, CloseableImage> backingCache) {
  if (!sImplLoaded) {
    try {
      final Class<?> clazz =
          Class.forName("com.facebook.fresco.animation.factory.AnimatedFactoryV2Impl");
      final Constructor<?> constructor = clazz.getConstructor(
          PlatformBitmapFactory.class,
          ExecutorSupplier.class,
          CountingMemoryCache.class);
      sImpl = (AnimatedFactory) constructor.newInstance(
          platformBitmapFactory,
          executorSupplier,
          backingCache);
    } catch (Throwable e) {
      // Head in the sand
    }
    if (sImpl != null) {
      sImplLoaded = true;
    }
  }
  return sImpl;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
/**
 * Probes whether the object corresponding to the mKey is in the cache.
 * Note that the act of probing touches the item (if present in cache),
 * thus changing its LRU timestamp.
 * <p>
 * This will be faster than retrieving the object, but it still has
 * file system accesses and should NOT be called on the UI thread.
 *
 * @param key the mKey to check
 * @return whether the keyed mValue is in the cache
 */
public boolean probe(final CacheKey key) {
  String resourceId = null;
  try {
    synchronized (mLock) {
      List<String> resourceIds = CacheKeyUtil.getResourceIds(key);
      for (int i = 0; i < resourceIds.size(); i++) {
        resourceId = resourceIds.get(i);
        if (mStorage.touch(resourceId, key)) {
          mResourceIndex.add(resourceId);
          return true;
        }
      }
      return false;
    }
  } catch (IOException e) {
    SettableCacheEvent cacheEvent = SettableCacheEvent.obtain()
        .setCacheKey(key)
        .setResourceId(resourceId)
        .setException(e);
    mCacheEventListener.onReadException(cacheEvent);
    cacheEvent.recycle();
    return false;
  }
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
@Override
public void remove(CacheKey key) {
  synchronized (mLock) {
    try {
      String resourceId = null;
      List<String> resourceIds = CacheKeyUtil.getResourceIds(key);
      for (int i = 0; i < resourceIds.size(); i++) {
        resourceId = resourceIds.get(i);
        mStorage.remove(resourceId);
        mResourceIndex.remove(resourceId);
      }
    } catch (IOException e) {
      mCacheErrorLogger.logError(
          CacheErrorLogger.CacheErrorCategory.DELETE_FILE,
          TAG,
          "delete: " + e.getMessage(),
          e);
    }
  }
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
@Override
public boolean hasKey(final CacheKey key) {
  synchronized (mLock) {
    if (hasKeySync(key)) {
      return true;
    }
    try {
      String resourceId = null;
      List<String> resourceIds = CacheKeyUtil.getResourceIds(key);
      for (int i = 0; i < resourceIds.size(); i++) {
        resourceId = resourceIds.get(i);
        if (mStorage.contains(resourceId, key)) {
          mResourceIndex.add(resourceId);
          return true;
        }
      }
      return false;
    } catch (IOException e) {
      return false;
    }
  }
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
@Override
public CacheKey getPostprocessedBitmapCacheKey(ImageRequest request, Object callerContext) {
    final Postprocessor postprocessor = request.getPostprocessor();
    final CacheKey postprocessorCacheKey;
    final String postprocessorName;
    if (postprocessor != null) {
        postprocessorCacheKey = postprocessor.getPostprocessorCacheKey();
        postprocessorName = postprocessor.getClass().getName();
    } else {
        postprocessorCacheKey = null;
        postprocessorName = null;
    }
    return new BitmapMemoryCacheKey(
            getCacheKeySourceUri(request.getSourceUri()),
            request.getResizeOptions(),
            request.getRotationOptions(),
            request.getImageDecodeOptions(),
            postprocessorCacheKey,
            postprocessorName,
            callerContext);
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
/**
 * Verify that multiple threads can write to the cache at the same time.
 */
@Test
public void testConcurrency() throws Exception {
  final CyclicBarrier barrier = new CyclicBarrier(3);
  WriterCallback writerCallback = new WriterCallback() {
    @Override
    public void write(OutputStream os) throws IOException {
      try {
        // Both threads will need to hit this barrier. If writing is serialized,
        // the second thread will never reach here as the first will hold
        // the write lock forever.
        barrier.await(10, TimeUnit.SECONDS);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
  };
  CacheKey key1 = new SimpleCacheKey("concurrent1");
  CacheKey key2 = new SimpleCacheKey("concurrent2");
  Thread t1 = runInsertionInSeparateThread(key1, writerCallback);
  Thread t2 = runInsertionInSeparateThread(key2, writerCallback);
  barrier.await(10, TimeUnit.SECONDS);
  t1.join(1000);
  t2.join(1000);
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
private Thread runInsertionInSeparateThread(final CacheKey key,
    final WriterCallback callback) {
  Runnable runnable = new Runnable() {

    @Override
    public void run() {
      try {
        mCache.insert(key, callback);
      } catch (IOException e) {
        fail();
      }
    }
  };
  Thread thread = new Thread(runnable);
  thread.setDaemon(true);
  thread.start();
  return thread;
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
@Override
public void onNewResultImpl(EncodedImage newResult, @Status int status) {
  // intermediate, null or uncacheable results are not cached, so we just forward them
  if (isNotLast(status) || newResult == null ||
      statusHasAnyFlag(status, DO_NOT_CACHE_ENCODED | IS_PARTIAL_RESULT)) {
    getConsumer().onNewResult(newResult, status);
    return;
  }

  final ImageRequest imageRequest = mProducerContext.getImageRequest();
  final CacheKey cacheKey =
      mCacheKeyFactory.getEncodedCacheKey(imageRequest, mProducerContext.getCallerContext());

  if (imageRequest.getCacheChoice() == ImageRequest.CacheChoice.SMALL) {
    mSmallImageBufferedDiskCache.put(cacheKey, newResult);
  } else {
    mDefaultBufferedDiskCache.put(cacheKey, newResult);
  }

  getConsumer().onNewResult(newResult, status);
}
 

import com.facebook.cache.common.CacheKey; //导入依赖的package包/类
private String verifyListenerOnWriteSuccessAndGetResourceId(
    CacheKey key,
    long itemSize) {
  ArgumentCaptor<CacheEvent> cacheEventCaptor = ArgumentCaptor.forClass(CacheEvent.class);
  mCacheEventListenerInOrder.verify(mCacheEventListener)
      .onWriteSuccess(cacheEventCaptor.capture());

  CacheEvent cacheEvent = cacheEventCaptor.getValue();
  CacheEventAssert.assertThat(cacheEvent)
      .isNotNull()
      .hasCacheKey(key)
      .hasItemSize(itemSize)
      .hasResourceIdSet();

  return cacheEvent.getResourceId();
}