in android/plugins/fresco/src/main/java/com/facebook/flipper/plugins/fresco/FrescoFlipperPlugin.java [141:389]
public void onConnect(FlipperConnection connection) {
super.onConnect(connection);
connection.receive(
"getAllImageEventsInfo",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, FlipperResponder responder) throws Exception {
if (!ensureFrescoInitialized()) {
return;
}
FlipperArray.Builder arrayBuilder = new FlipperArray.Builder();
for (FlipperObject obj : mEvents) {
arrayBuilder.put(obj);
}
mEvents.clear();
FlipperObject object =
new FlipperObject.Builder().put("events", arrayBuilder.build()).build();
responder.success(object);
}
});
connection.receive(
"listImages",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, FlipperResponder responder) throws Exception {
if (!ensureFrescoInitialized()) {
return;
}
mPerfLogger.startMarker("Sonar.Fresco.listImages");
final boolean showDiskImages = params.getBoolean("showDiskImages");
final ImagePipelineFactory imagePipelineFactory = Fresco.getImagePipelineFactory();
final CountingMemoryCacheInspector.DumpInfo bitmapMemoryCache =
new CountingMemoryCacheInspector<>(
imagePipelineFactory.getBitmapCountingMemoryCache())
.dumpCacheContent();
final CountingMemoryCacheInspector.DumpInfo encodedMemoryCache =
new CountingMemoryCacheInspector<>(
imagePipelineFactory.getEncodedCountingMemoryCache())
.dumpCacheContent();
try {
responder.success(
getImageList(bitmapMemoryCache, encodedMemoryCache, showDiskImages));
mPerfLogger.endMarker("Sonar.Fresco.listImages");
} finally {
bitmapMemoryCache.release();
encodedMemoryCache.release();
}
}
});
connection.receive(
"getImage",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, final FlipperResponder responder)
throws Exception {
if (!ensureFrescoInitialized()) {
return;
}
mPerfLogger.startMarker("Sonar.Fresco.getImage");
final String imageId = params.getString("imageId");
final CacheKey cacheKey = mFlipperImageTracker.getCacheKey(imageId);
if (cacheKey == null) {
respondError(responder, "ImageId " + imageId + " was evicted from cache");
mPerfLogger.cancelMarker("Sonar.Fresco.getImage");
return;
}
final ImagePipelineFactory imagePipelineFactory = Fresco.getImagePipelineFactory();
// try to load from bitmap cache
@Nullable
CloseableImage closeableImage =
imagePipelineFactory.getBitmapCountingMemoryCache().inspect(cacheKey);
if (closeableImage instanceof CloseableBitmap) {
@Nullable Bitmap bitmap = ((CloseableBitmap) closeableImage).getUnderlyingBitmap();
if (bitmap != null) {
loadFromBitmapCache(bitmap, imageId, cacheKey, responder);
mPerfLogger.endMarker("Sonar.Fresco.getImage");
return;
}
}
// try to load from encoded cache
PooledByteBuffer encoded =
imagePipelineFactory.getEncodedCountingMemoryCache().inspect(cacheKey);
if (encoded != null) {
loadFromEncodedCache(encoded, imageId, cacheKey, responder);
mPerfLogger.endMarker("Sonar.Fresco.getImage");
return;
}
// try to load from disk
loadFromDisk(imageId, cacheKey, responder);
}
private void loadFromBitmapCache(
final Bitmap bitmap,
final String imageId,
final CacheKey cacheKey,
final FlipperResponder responder) {
String encodedBitmap = bitmapToBase64Preview(bitmap, mPlatformBitmapFactory);
responder.success(
getImageData(
imageId,
mFlipperImageTracker.getUriString(cacheKey),
bitmap.getWidth(),
bitmap.getHeight(),
BitmapUtil.getSizeInBytes(bitmap),
encodedBitmap));
}
private void loadFromEncodedCache(
final PooledByteBuffer encoded,
final String imageId,
final CacheKey cacheKey,
final FlipperResponder responder)
throws Exception {
byte[] encodedArray = ByteStreams.toByteArray(new PooledByteBufferInputStream(encoded));
Pair<Integer, Integer> dimensions = BitmapUtil.decodeDimensions(encodedArray);
if (dimensions == null) {
respondError(responder, "can not get dimensions withId=" + imageId);
return;
}
responder.success(
getImageData(
imageId,
mFlipperImageTracker.getUriString(cacheKey),
dimensions.first,
dimensions.second,
encodedArray.length,
dataFromEncodedArray(encodedArray)));
}
private void loadFromDisk(
final String imageId, final CacheKey cacheKey, final FlipperResponder responder) {
Task<EncodedImage> t =
Fresco.getImagePipelineFactory()
.getMainBufferedDiskCache()
.get(cacheKey, new AtomicBoolean(false));
t.continueWith(
new Continuation<EncodedImage, Void>() {
public Void then(Task<EncodedImage> task) throws Exception {
if (task.isCancelled() || task.isFaulted()) {
respondError(responder, "no bitmap withId=" + imageId);
mPerfLogger.cancelMarker("Sonar.Fresco.getImage");
return null;
}
Preconditions.checkNotNull(task);
final EncodedImage image = task.getResult();
try {
InputStream stream = Preconditions.checkNotNull(image.getInputStream());
byte[] encodedArray = ByteStreams.toByteArray(stream);
responder.success(
getImageData(
imageId,
Preconditions.checkNotNull(
mFlipperImageTracker.getLocalPath(cacheKey)),
image.getWidth(),
image.getHeight(),
encodedArray.length,
dataFromEncodedArray(encodedArray)));
} finally {
EncodedImage.closeSafely(image);
}
mPerfLogger.endMarker("Sonar.Fresco.getImage");
return null;
}
});
}
});
connection.receive(
"clear",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, FlipperResponder responder) {
if (!ensureFrescoInitialized()) {
return;
}
mPerfLogger.startMarker("Sonar.Fresco.clear");
final String type = params.getString("type");
switch (type) {
case "memory":
final ImagePipelineFactory imagePipelineFactory = Fresco.getImagePipelineFactory();
imagePipelineFactory.getBitmapMemoryCache().removeAll(ALWAYS_TRUE_PREDICATE);
break;
case "disk":
Fresco.getImagePipeline().clearDiskCaches();
break;
}
mPerfLogger.endMarker("Sonar.Fresco.clear");
}
});
connection.receive(
"trimMemory",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, FlipperResponder responder) throws Exception {
if (!ensureFrescoInitialized()) {
return;
}
if (mMemoryManager != null) {
mMemoryManager.trimMemory(
DebugMemoryManager.ON_SYSTEM_LOW_MEMORY_WHILE_APP_IN_FOREGROUND);
}
}
});
connection.receive(
"enableDebugOverlay",
new FlipperReceiver() {
@Override
public void onReceive(FlipperObject params, FlipperResponder responder) throws Exception {
if (!ensureFrescoInitialized()) {
return;
}
final boolean enabled = params.getBoolean("enabled");
if (mDebugPrefHelper != null) {
mDebugPrefHelper.setDebugOverlayEnabled(enabled);
}
}
});
if (mDebugPrefHelper != null) {
mDebugPrefHelper.setDebugOverlayEnabledListener(
new FrescoFlipperDebugPrefHelper.Listener() {
@Override
public void onEnabledStatusChanged(boolean enabled) {
sendDebugOverlayEnabledEvent(enabled);
}
});
sendDebugOverlayEnabledEvent(mDebugPrefHelper.isDebugOverlayEnabled());
}
}