Skip to content
CAI
Software that uses CAICheck a score

facebook/fresco

52.4

Adequate · 13 November 2026

97.7k

lines of production code

Kotlin

with Java, JavaScript

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add BetterImageSpan for improved inline image alignment and margins

Introduces BetterImageSpan, a replacement for Android's standard ImageSpan that provides more precise control over inline image rendering. Users can now center images against text using ALIGN\_CENTER, avoid unnecessary whitespace with ALIGN\_BOTTOM, and add custom margins around images via a Rect parameter. The class includes a normalizeAlignment helper to facilitate migration from existing ImageSpan usage.

fbcore/src/main/java/com/facebook/widget · high confidence

Add Data URI image format sample to the showcase app

The showcase application now includes a new sample demonstrating how to load and display images from Data URIs. This addition introduces the ImageFormatDataUriFragment, which utilizes the VitoView component to render a base64-encoded PNG image and displays the corresponding URI string in the user interface.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/datauri · high confidence

Add FlipperObjectHelper for serializing Fresco image data

Introduces the FlipperObjectHelper class in the Flipper Fresco plugin to serialize various Fresco image-related objects (such as ImageRequest, ImageDecodeOptions, ResizeOptions, RotationOptions, RoundingParams, ImagePerfData, and ImageInfo) into FlipperObject structures. This enables detailed inspection of image request configurations and performance metrics within the Flipper UI.

tools/flipper-fresco-plugin/src/main/java/com/facebook/flipper/plugins/fresco/objecthelper · high confidence

Add Nine-Patch image decoding example for Vito Litho

The Showcase sample now includes a new example demonstrating how to decode and display Android nine-patch images using Fresco Vito with Litho. This addition introduces a custom image decoder and drawable factory within the sample code, allowing users to see how to integrate native nine-patch rendering into Vito-based Litho components.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito/ninepatch · high confidence

Add Volley as a network backend for image fetching

Users can now use the Volley library as a backend for network image fetching in the image pipeline. This new VolleyNetworkFetcher integrates with a provided Volley RequestQueue to handle HTTP requests, bypassing Volley's internal cache to allow the image pipeline to manage caching. Note that because Volley does not expose InputStreams, responses are passed as complete byte arrays, which means progressive JPEG streaming is not supported.

imagepipeline-volley · high confidence

Add Volley as an image pipeline backend

Users can now use the Volley library as a network fetcher for the image pipeline. This change introduces a new backend module containing a \VolleyNetworkFetcher\ and a configuration factory (\VolleyImagePipelineConfigFactory\) that allows applications to build an \ImagePipelineConfig\ backed by a provided Volley \RequestQueue\. It also includes a \RawRequest\ helper for fetching raw byte arrays without caching.

imagepipeline-backends/imagepipeline-volley/src/main/java · high confidence

Add Volley memory cache implementation to comparison samples

The comparison sample app now includes a new Volley configuration that provides a default bitmap memory cache using AndroidX's LruCache. This addition allows users to benchmark Volley's caching behavior alongside other image loading libraries within the sample application.

comparison · high confidence

Add WebP image display sample to the Showcase app

The Showcase app now includes a new sample screen that demonstrates how to display static, translucent, and animated WebP images using Fresco's VitoView component. This addition allows users to see practical examples of WebP rendering and check WebP support status on the device.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/webp · high confidence

Add XML image format showcase

The Showcase app now includes a new section for displaying various Android XML-based image formats. Users can select from Vector, Nine patch, Layer list, Level list, State list, and Bitmap XML drawables via a spinner, which are then rendered using Fresco's VitoView component.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/xml · high confidence

Add configuration factories for Universal Image Loader and Volley in the comparison sample

The comparison sample app now includes dedicated factory classes to initialize and provide singleton instances for image loading libraries. SampleUilFactory configures the Universal Image Loader with specific memory and disk cache sizes, along with placeholder and error drawables. SampleVolleyFactory sets up Volley's RequestQueue with a disk-based cache and provides an ImageLoader backed by a custom memory cache. These changes support the sample's ability to compare different image loading implementations.

samples/comparison/src/main/java/com/facebook/samples/comparison/configs/uil, samples/comparison/src/main/java/com/facebook/samples/comparison/configs/volley · high confidence

Add native memory chunk implementation for image pipeline

The image pipeline now includes a new native component (memchunk) that provides low-level memory management capabilities. This addition introduces a static library built from C code, exposing native methods for allocating and freeing memory, copying data to and from Java byte arrays, performing memory copies, and reading individual bytes. These functions are registered with the Java Native Interface to support the \com.facebook.imagepipeline.memory.NativeMemoryChunk\ class, enabling efficient direct memory access for image processing operations.

imagepipeline-native/src/main/jni/memchunk · high confidence

Add simple BufferMemoryChunk implementation for native memory management

Introduces a new memory type module providing a \BufferMemoryChunk\ class that wraps a direct \ByteBuffer\ to manage memory in native space, along with a corresponding \BufferMemoryChunkPool\ for pooling these chunks. This allows the image pipeline to utilize direct byte buffers for image data storage, offering an alternative memory management strategy within the Fresco library.

memory-types/simple/src/main · high confidence

Add size selection preference with SeekBar

The Scroll Perf sample now includes a new SizePreferences UI component that allows users to adjust a size parameter via a SeekBar. This preference persists the selected value and updates the displayed text in real-time as the user drags the slider.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/preferences · high confidence

Add support for GLB and HEIF/HEIC media types

MediaUtils now recognizes GLB (model/gltf-binary) and HEIF/HEIC (image/heif, image/heic) file extensions, allowing applications to correctly identify and handle these formats. This is achieved by adding GLB to the additional allowed MIME types map and introducing a new MimeTypeMapWrapper that extends the system's native MIME type resolution with explicit mappings for HEIF and HEIC, ensuring broader media compatibility beyond what the underlying Android platform provides.

fbcore/src/main/java/com/facebook/common/media · high confidence

Added DataSourceImageSource for direct DataSource integration

A new DataSourceImageSource class has been added to the core implementation, allowing images to be supplied directly via a DataSource. This provides a more direct path for image data sources compared to previous abstractions.

core-java-impl · high confidence

Added Imgur image URL fetching utilities for the comparison sample

The comparison sample now includes a new set of helper classes in the \urlsfetcher\ package to asynchronously fetch image URLs from Imgur. This includes \ImageUrlsFetcher\ to handle the API requests and JSON parsing, \ImageUrlsRequest\ and \ImageUrlsRequestBuilder\ to configure download parameters, and enums \ImageFormat\ and \ImageSize\ to define supported image types and resizing suffixes. This allows the sample app to retrieve and display images from Imgur albums.

samples/comparison/src/main/java/com/facebook/samples/comparison/urlsfetcher · high confidence

Added Keyframes animated image support to the Showcase sample

The Showcase sample app now includes a dedicated section for displaying Keyframes animated images. This change introduces a new decoder, format checker, and drawable factory to parse and render Keyframes content, along with a UI fragment that demonstrates the animation using a VitoView and allows users to toggle a checkerboard background.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/keyframes · high confidence

Added Movie-based animated image rendering support

The animated-gif-lite module now includes a new implementation for rendering animated images using Android's native \Movie\ class. This change introduces \MovieAnimatedImage\, \MovieDrawer\, \MovieFrame\, and \MovieScaleHolder\ classes within the \draw\ package, enabling the library to decode and display animated GIFs by leveraging the platform's built-in media capabilities rather than a custom decoder.

animated-gif-lite/src/main/java/com/facebook/animated/giflite/draw · high confidence

Added ProGuard configuration and build artifacts for scrollperf sample

The scrollperf sample now includes a .gitignore file to exclude build directories and a proguard-scrollperf.pro file containing rules to preserve interfaces and native methods annotated with @DoNotStrip and @DoNotOptimize, as well as the SoLoader initialization method. This ensures that the sample project correctly handles code shrinking and obfuscation during release builds without stripping critical Facebook-specific annotations or native bindings.

samples/scrollperf · high confidence

Added Progressive JPEG sample with frame-level logging

The Showcase app now includes a new Progressive JPEG sample that demonstrates rendering progressive images using the VitoView API. Users can toggle progressive rendering on or off via a switch and select from various sample images (small, medium, large, and slow) via a spinner. The sample provides detailed debugging output in the UI, logging each intermediate and final image frame's quality metrics (goodEnough, fullQuality, quality) along with timestamps, helping developers understand how progressive JPEGs load over time.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/pjpeg · high confidence

Added VitoImage Composable for Jetpack Compose

Users can now display images in Jetpack Compose UIs using the new VitoImage composable. This component wraps the existing VitoView to provide image loading capabilities within Compose layouts, accepting an ImageSource, optional ImageOptions, and a callerContext.

vito/compose · high confidence

Added bitmap animation sample with cache selection and debugging

The Animation v2 sample app now includes a new bitmap animation demo that allows users to switch between different frame caching strategies (NoOp, Keep Last, Naive All-Frames, and Fresco-based caches) via a UI spinner. It also provides a debug fragment that visualizes frame cache status (cached, reused, created, fallback) and logs animation statistics, helping developers understand how different caching backends impact performance and memory usage.

samples/animation2/src/main/java/com/facebook/samples/animation2/bitmap · high confidence

Added image format color override example

The Showcase app now includes a new example demonstrating how to override the image decoder for specific requests. This feature allows users to decode custom color XML formats (e.g., \\<color\>\#rrggbb\</color\>\) by registering a custom \ImageDecoder\ and \DrawableFactory\ via \ImageOptions\, providing a practical reference for implementing custom image format support in Fresco.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/color · high confidence

Added image loading time measurement listener

A new debug listener interface and implementation have been added to measure the time taken for an image to load. The \ImageLoadingTimeListener\ interface allows consumers to receive callbacks when a final image is set, providing the duration in milliseconds from the request submission to the final image being displayed. This enables debugging and performance monitoring of image loading times within the drawee component.

drawee/src/main/java/com/facebook/drawee/debug/listener · high confidence

Added instrumentation classes for image request tracking in the Scrollperf sample

The Scrollperf sample app now includes a new instrumentation package containing classes to track and visualize image loading performance. InstrumentedVitoView extends ImageView to hook into Vito's image lifecycle, reporting start, success, failure, and cancellation events to a PerfListener which aggregates statistics like average wait time and request counts. The Instrumentation class provides a visual overlay on the view to display the current state and timing of the active image request, aiding in visual inspection of performance during scrolling.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/instrumentation · high confidence

Added instrumentation for tracking image request performance in the comparison sample

The comparison sample now includes a new instrumentation package that allows developers to track and visualize the performance of image loading requests. This includes an \Instrumentation\ class that measures start, success, failure, and cancellation times, along with specific instrumented views (\InstrumentedDraweeView\, \InstrumentedImageView\, \InstrumentedNetworkImageView\) that hook into the image lifecycle to report these metrics. A \PerfListener\ aggregates these stats (e.g., average wait time, outstanding requests), and the instrumented views draw an overlay on the UI to display the current request state and timing for easier visual inspection during development.

samples/comparison/src/main/java/com/facebook/samples/comparison/instrumentation · high confidence

Added local drawable animation backend for frame-by-frame animations

The Animation v2 sample now includes a local drawable backend that chains local Android drawables together to render frame-by-frame animations. This new component allows users to define animation sequences using local drawable resource IDs, configure loop counts and frame durations via a builder, and manage caching of the drawable instances for efficient rendering.

samples/animation2/src/main/java/com/facebook/samples/animation2/local · high confidence

Added sample color animation backend and fragment

The Animation v2 sample app now includes a simple color cycling animation. This change adds an \ExampleColorBackend\ that cycles through a predefined list of colors and a \SimpleColorFragment\ that displays this animation in an \ImageView\. Users can tap the view to start or stop the animation, and a toast message will appear if the animation is inactive for more than 2 seconds.

samples/animation2/src/main/java/com/facebook/samples/animation2/color · high confidence

Added static WebP decoding support via native library integration

This change introduces the core Java/Kotlin components for decoding WebP images using a statically linked native library. The \StaticWebpNativeLoader\ ensures the \static-webp.so\ native library is loaded exactly once. The \WebPImageDecoder\ implements the image pipeline's decoder interface, routing WebP data to the new implementation. The \WebpBitmapFactoryImpl\ provides the actual decoding logic by hooking into Android's \BitmapFactory\ methods, ensuring the native library is initialized before decoding and handling stream buffering and error logging.

static-webp/src/main/java · high confidence

Added test utilities for memory pool stats and bitmap mocking

The imagepipeline-test module now includes helper classes to support testing: PoolStats provides a way to inspect memory pool usage (used/free bytes and counts, plus bucket-level statistics), IntPair is a simple value class for bucket data, and MockBitmapFactory offers static methods to create Mockito-based Bitmap mocks with configurable dimensions and configurations.

imagepipeline-test · high confidence

Animation2 sample app introduces backend selection and media controls

The Animation2 sample application now provides a user interface for selecting between different animation backends (color, local drawable, and bitmap) via a spinner, and includes a dedicated media control fragment with play/pause, seek, and reset functionality. The app initializes Fresco for image handling and wraps animation backends with an inactivity check that displays a toast notification when no frames are drawn for over two seconds.

samples/animation2/src/main/java/com/facebook/samples/animation2 · high confidence

Drawee controller now supports viewport visibility hints and multiple listeners

The Drawee controller now allows clients to notify the system when the image view enters or leaves the viewport via the new ControllerViewportVisibilityListener interface, enabling better resource management for off-screen images. Additionally, the controller architecture has been updated to support multiple controller listeners simultaneously through the new ControllerListener2 and ForwardingControllerListener2 mechanisms, improving extensibility and allowing more granular event handling for image loading states.

drawee/src/main/java/com/facebook/drawee/controller · high confidence

Drawee-to-Vito compatibility layer for XML inflation and listener wrapping

This change introduces a compatibility layer in the \vito/drawee-support\ module that allows existing Drawee XML attributes to be parsed into Vito \ImageOptions\. The new \VitoViewInflater\ reads standard Drawee hierarchy attributes (such as scale types, placeholders, fade durations, and rounding parameters) and converts them into Vito-specific options, including support for rounded corners and borders. It also provides \ControllerListenerWrapper\ to bridge legacy Drawee listeners to Vito's image listener interface, and \DrawableFactoryWrapper\ to adapt drawable factories. This enables applications to migrate views to Vito while retaining their existing XML configurations.

vito/drawee-support/src/main/java · high confidence

Fresco Showcase app UI and sample fragments

The Fresco Showcase application has been updated with a new Material Design-based interface, including a main activity with a navigation drawer, toolbar, and content area. Numerous sample fragments have been added or migrated to demonstrate various image loading capabilities, such as GIF, WebP, SVG, Keyframes, progressive JPEG, and XML-based drawables. The app now includes examples for image pipeline features like prefetching, resizing, region decoding, post-processing, and partial requests, as well as Vito-specific samples for image options configuration and Litho integration.

samples/showcase/src/main/res · high confidence

Fresco Vito Showcase: New Image Options Configurator and Vito-specific Samples

The Fresco Showcase app now includes a comprehensive set of samples demonstrating the new Fresco Vito image loading library. A new Image Options configuration fragment allows users to interactively test Vito features including scaling, rounding, borders, color filters, placeholders, error images, overlays, fading, progress bars, post-processors, rotation, resizing, and custom drawable factories. Additional samples illustrate Vito-specific capabilities such as region decoding with custom parent bounds and focus points, multi-URI loading strategies (first available, increasing quality), displaying Drawable sources directly, retaining image sources for dynamic replacement, Litho-based galleries and lists, slideshow components, and media picker integration.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito · high confidence

Introduce ContextChain and ImageAttribution for product metadata tracking

Added ContextChain, a new serializable metadata structure that allows chaining product and infrastructure tags (e.g., feed, profile, feature names) for logging and identification, along with an ImageAttribution interface to retrieve the calling class name and associated context chain. This enables better traceability of image loading and other operations by attaching structured metadata to the call stack.

fbcore/src/main/java/com/facebook/common/callercontext · high confidence

Introduce Fresco Vito options module with Kotlin-based image configuration

This change introduces the new \vito/options\ module, migrating core image configuration classes (ImageOptions, EncodedImageOptions, DecodedImageOptions, RoundingOptions) from Java to Kotlin. The module exposes new public APIs for configuring image display, including placeholder and error colors, background drawables, and auto-play/stop controls for media. It also adds support for dynamic disk cache choices and ensures the progress indicator is retained across intermediate images. A new \ImageOptionsDrawableFactory\ interface allows custom drawable creation, and the module includes tests for rounding options.

vito/options · high confidence

Introduce Kotlin-based Vito core implementation

The Vito image rendering core has been migrated from Java to Kotlin, introducing a new \KFrescoController\ and \KFrescoVitoDrawable\ to handle image fetching, layer management, and rendering. This change brings native support for animated images via \Drawable.Callback\ integration, enables configurable fade-in/fade-out animations, and adds a comprehensive debug overlay with providers for image origin, dimensions, fit ratio, and wasted memory. The migration also includes a new \ImageReleaseScheduler\ for optimized resource cleanup, support for color filters and borders, and improved listener management to prevent crashes during image resets.

vito/core-impl/src/main · high confidence

Introduce Litho-based Slideshow Component

Added a new Litho component (FrescoVitoSlideshowComponentSpec) and its associated drawable (FrescoVitoSlideshowDrawable) to render image slideshows. The component manages a sequence of images via Fresco, handling transitions, auto-advancement timers, and state updates (playing/pausing) within the Litho lifecycle.

vito/litho-slideshow · high confidence

Introduce MultiVitoDrawableHolder for managing multiple Vito drawables

Added a new MultiVitoDrawableHolder class that allows managing a collection of VitoDrawableHolder instances. This component provides methods to add, remove, and iterate over multiple drawables, handling attachment and detachment lifecycle events for all contained holders. It also includes a draw method to render all managed drawables to a canvas, facilitating the display of multiple images or complex drawable compositions within the Vito2 framework.

vito/drawable-holder · high confidence

Introduce Vito Image Live Editing tool

Adds a new live editing tool for Vito images, allowing developers to modify image sources and options (such as rounding, borders, scale types, color filters, and fading) in real-time via an on-screen overlay. The feature includes a draggable UI with buttons for navigating images, editing options, viewing image info, and applying sample values, while tracking image performance and handling overlay permissions.

liveeditor · high confidence

Introduce Vito Kotlin renderer with animated image and shape support

The Vito renderer now includes a new Kotlin implementation that supports animated images and various shape types. Users can now display animated drawables, which automatically start and stop based on attachment state, and render images with specific paint flags for filtering and dithering. The renderer also introduces support for circular images with configurable anti-aliasing, as well as rect, rounded-rect, and path shapes.

renderer · high confidence

Introduce Vito initialization module

A new \vito/init\ module has been added to centralize the startup logic for Fresco Vito. This module provides the \FrescoVito\ class, which handles the single-thread-safe initialization of the Vito provider, configures image pipeline utilities (including native circular bitmap rounding), and sets up the debug overlay factory. It also introduces an API to pass a global image performance listener supplier during initialization, allowing for more accurate on-screen image tracking.

vito/init/src/main/java · high confidence

Introduce Vito text span component for image rendering

This change adds a new Vito-based text span implementation to the Fresco library, allowing images to be rendered within text layouts using the Vito image pipeline. The new \VitoSpan\ class acts as a replacement span that delegates drawing and sizing to an underlying \BetterImageSpan\, while \VitoSpanLoader\ provides static methods to create spans, load images via \VitoImageRequest\, and manage the lifecycle of the span when attached to or detached from a view. This enables developers to integrate Vito-powered image loading directly into \Spannable\ text structures.

vito/textspan · high confidence

Introduce VitoView for image loading with improved memory safety and transition support

The Vito image loading component now includes a new VitoView API (VitoView.kt and VitoViewImpl2.kt) that allows displaying images in any View or ImageView. This release introduces several behavioral improvements: it fixes memory leaks in RecyclerView scenarios by preserving the refetchRunnable across view detach/reattach cycles and optionally using WeakReferences for the target view; it adds configurable release strategies (immediate, delayed, or disabled) when a view is detached from the window; and it introduces a VitoTransition utility to animate scale and focus changes between images. Additionally, a new ImageViewWithAspectRatio component is provided to maintain aspect ratios during layout.

vito/view · high confidence

Introduce drawee-span module for embedding Drawee images in text

A new \drawee-span\ module has been added, providing \DraweeSpan\ and \DraweeSpanStringBuilder\ to embed Fresco/Vito images directly within \Spannable\ text, along with \SimpleDraweeSpanTextView\ to manage the view lifecycle and attach/detach events for animated images.

drawee-span · high confidence

Introduce experimental animated-drawable module with new animation backend

Adds a new experimental animated-drawable module that provides a modern, Kotlin-first animation backend for Fresco. This includes the core AnimationBackend interface, a BitmapAnimationBackend implementation for rendering bitmap frames, and a comprehensive frame preparation and caching system (including BitmapFrameCache, BitmapFramePreparer, and FrameLoaderStrategy). The new backend supports advanced features like configurable loop counts, thumbnail fallbacks for incomplete animations, corner rounding, and inactivity-based cache dropping to improve memory usage and performance on low-end devices.

animated-drawable · high confidence

Introduce new cache event listener and key abstractions

The imagepipeline-base module now includes a new CacheEventListener interface and a BaseCacheEventListener implementation, allowing applications to monitor cache hits, misses, writes, and evictions. Additionally, a CacheKey interface and its implementations (SimpleCacheKey, MultiCacheKey, DebuggingCacheKey) have been added to provide strongly typed, URI-aware cache keys with debugging capabilities, replacing the previous Object-based key approach.

imagepipeline-base · high confidence

Introduce open-source Vito Litho image components

Adds the \FrescoVitoImage2Spec\ and \FrescoVitoTapToRetryImageSpec\ Litho components, enabling developers to display images with Vito's advanced features (such as prefetching, dynamic sizing, and tap-to-retry) within Litho-based UIs. The new \FrescoVitoImage2Spec\ component integrates with the Vito image pipeline to handle loading, caching, and lifecycle management, while the \FrescoVitoTapToRetryImageSpec\ provides a wrapper that automatically handles image failure states by allowing users to retry loading via a tap gesture.

vito/litho · high confidence

Introduce urimod module for URI modification and fetch strategy control

Adds the new \urimod\ module to Fresco, providing a pluggable URI modification system and explicit fetch strategy definitions. The module introduces \UriModifierInterface\ and a \NopUriModifier\ default implementation, allowing consumers to modify image URIs based on viewport, scale type, and network conditions, as well as prefetch URIs. It also defines \FetchStrategy\ enums (\SmartFetchStrategy\ and \ClassicFetchStrategy\) to control prefetching behaviors such as disk cache timeouts, main thread execution, and product-specific disabling. This change establishes the infrastructure for adaptive image fetching and URI manipulation within the Fresco pipeline.

urimod · high confidence

Introduction of Android Ashmem-backed memory chunks

Added a new memory implementation that uses Android's SharedMemory (ashmem) API for image pipeline buffers. This change introduces AshmemMemoryChunk and AshmemMemoryChunkPool, which manage memory chunks backed by shared memory on Android API 27+, providing an alternative to standard heap-based memory allocation for image processing.

memory-types/ashmem/src/main · high confidence

Introduction of GifLite decoder using Android's Movie class

A new GifDecoder implementation has been added to the animated-gif-lite module, enabling the decoding of animated GIFs by leveraging Android's native {@link Movie} class. This decoder processes GIF metadata and frame disposal methods to construct a sequence of frames, supporting configuration options such as bitmap config for optimized rendering within the Fresco image pipeline.

animated-gif-lite/src/main/java/com/facebook/animated/giflite · high confidence

Introduction of Kotlin-based Vito Renderer

Fresco now includes a new rendering engine written in Kotlin, located in the vito/renderer module. This implementation introduces a data-driven rendering pipeline where ImageRenderer creates specific render commands for Bitmap, Color, and Drawable data models, handling shape masking, alpha multiplication, and canvas transformations. The renderer also provides infrastructure for canvas transformations via CanvasTransformation and CanvasTransformationHandler, and includes utility functions for color alpha manipulation, offering a modernized alternative to the previous Java-based rendering path.

vito/renderer · high confidence

Introduction of NativeMemoryChunk and NativeMemoryChunkPool classes

Added new Kotlin classes \NativeMemoryChunk\ and \NativeMemoryChunkPool\ within the \com.facebook.imagepipeline.memory\ package. \NativeMemoryChunk\ provides a wrapper for native memory chunks, enabling read/write operations and copying via JNI, while \NativeMemoryChunkPool\ manages a pool of these chunks, integrating with the memory trimmable registry and pool parameters.

memory-types/nativememory/src/main · high confidence

Introduction of WebP support detection and factory interfaces

The fbcore module now includes new Kotlin files to handle WebP image support: WebpSupportStatus provides runtime detection of simple, lossless, and extended WebP formats by inspecting file headers, while WebpBitmapFactory and BitmapCreator define interfaces for decoding WebP images and allocating bitmaps. This allows the library to determine platform WebP capabilities and delegate decoding to an optional static-webp implementation when native support is insufficient.

fbcore/src/main/java/com/facebook/common/webp · high confidence

Introduction of native bitmap copying utility

The image pipeline now includes a new Kotlin utility class, Bitmaps, which provides a copyBitmap method to efficiently blit pixel data between two Bitmaps using native code. This functionality is supported by the ImagePipelineNativeLoader, which ensures the underlying libimagepipeline.so library is loaded before use, enabling faster bitmap operations for users relying on native acceleration.

imagepipeline-native/src/main/java · high confidence

New AttachDetachListener interface for view lifecycle events

A new AttachDetachListener interface has been added to the fbcore library, allowing components to receive callbacks when a View is attached to or detached from a window. This enables cleaner handling of view lifecycle events without requiring direct View subclassing or complex observer patterns.

fbcore/src/main/java/com/facebook/common/lifecycle · high confidence

New CircleProgressBarDrawable for circular progress indication

A new CircleProgressBarDrawable class has been added to the samples/contrib module, providing a circular progress bar implementation. This drawable extends ProgressBarDrawable and renders a stroke-based arc that updates based on the progress level, allowing users to display circular progress indicators in their applications.

samples/contrib · high confidence

New Flipper module for Fresco image debugging

A new \tools/flipper\ module has been added to integrate Flipper with Fresco's image pipeline. This includes a \DebugImageTracker\ interface with a new \clear()\ method to reset tracking data, a \FlipperImageTracker\ implementation that records image requests, cache keys, and performance data (via \ImagePerfDataListener\), and a \FlipperCacheKeyFactory\ that hooks into cache key generation to track images. A \NoOpDebugImageTracker\ is also provided for non-debug builds, along with supporting utilities like \LruMap\.

tools/flipper · high confidence

New Fresco Flipper plugin for debugging image caches and requests

This change introduces the \FrescoFlipperPlugin\ and supporting classes (\FrescoFlipperRequestListener\, \FrescoFlipperDebugPrefHelper\) to the Fresco library's tooling. For developers, this provides a new Flipper plugin that allows inspecting Fresco's memory and disk caches (via the 'Sonar' feature) and tracking image request lifecycle events. The plugin exposes methods to list cached images, retrieve image event info, and monitor debug overlay status, facilitating deeper debugging of image loading performance and cache behavior within Android apps using Fresco.

tools/flipper-fresco-plugin/src/main/java/com/facebook/flipper/plugins/fresco · high confidence

New GifAnimationBackend implementation for GIF drawing

Added a new GifAnimationBackend class in the animated-gif-lite drawable package that implements the AnimationBackend interface to handle GIF rendering. This backend uses Android's native Movie class to draw frames and includes logic to scale the GIF content to fit the view bounds while maintaining aspect ratio, exposing metadata such as frame count, duration, and loop count.

animated-gif-lite/src/main/java/com/facebook/animated/giflite/drawable · high confidence

New GifMetadataDecoder for extracting GIF metadata

The library introduces a new GifMetadataDecoder class that parses GIF files to extract structural metadata such as screen dimensions, frame count, loop count, and per-frame timing and disposal settings. This decoder supports optional output streaming to write fixed versions of GIFs when necessary, enabling downstream components to access detailed animation properties without decoding pixel data.

animated-gif-lite/src/main/java/com/facebook/animated/giflite/decoder · high confidence

New HashCode helper utility added

A new Kotlin object named HashCode has been added to the fbcore memory helper package. It provides a static method to extend an existing hash code value by combining it with another object's hash code, which is a common pattern for implementing hashCode() in data classes.

fbcore/src/main/java/com/facebook/memory · high confidence

New ImageSource implementations and Smart Fetch opt-in in Fresco Vito

The Fresco Vito source module introduces several new ImageSource types to support different image origins: BitmapImageSource for direct Bitmaps, ColorImageSource for solid colors, DrawableImageSource for Android Drawables, and DrawableResImageSource for resource IDs (which now supports configurable prefetching via a custom function and a global enable flag). EmptyImageSource has been enhanced with a reason string and an isExpectedEmpty flag to distinguish expected empty states from failures. Additionally, SmartImageSource now accepts a SmartFetchOptIn parameter, allowing product-level opt-in to smart fetching behavior, and FirstAvailableImageSource enables fallback chains across multiple sources.

source · high confidence

New Kotlin Vito Renderer showcase examples

The Showcase app now includes a set of Kotlin-based example fragments demonstrating the new Vito Renderer implementation. Users can explore specific capabilities including color filter application across various shapes, fade-in/fade-out animations on image layers, rendering with different shape types (rectangles, circles, rounded rects, paths), and scale type handling via image layers. These examples utilize helper utilities to render \ImageDataModel\ instances directly as Android Drawables.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito/renderer · high confidence

New Kotlin extension functions for Vito image loading

This change introduces a new Kotlin multiplatform library (vito/ktx) that provides convenience extension functions for integrating Vito image loading into Android views. Developers can now use idiomatic Kotlin syntax to display images, such as calling \view.show(uri)\ or \view.show(uri, options, listener, callerContext)\ directly on any View instance. The library also includes extensions for \ImageSource\, allowing \Uri\ and \String\ objects to be converted into \ImageSource\ instances, and supports chaining low-resolution placeholders via \withLowResImage\. These additions simplify the API surface for Kotlin users without altering the underlying Java-based Vito implementation.

vito/ktx · high confidence

New ScrollPerf sample app with configurable image pipeline settings

The ScrollPerf sample application has been introduced to demonstrate Java-based Fresco integration. The app allows users to configure image decoding behavior through a settings interface, including toggling downsampling modes, enabling decode cancellation, and adjusting the number of decoding threads. It also supports Vito overlay visualization and handles memory chunk types based on build flavors (native vs. no-native-code).

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf · high confidence

New Vito Live Editor tool for inspecting and editing image options

The Vito Live Editor is now available as a standalone tool for debugging and modifying image display properties. It provides an interactive overlay to select and highlight images on screen, with navigation sorted by visual position. The editor includes an 'Image Info' dialog that displays detailed source information (such as type and URLs for complex sources like IncreasingQuality or FirstAvailable), shows the cache origin with a color-coded indicator, and allows users to tap rows to copy values to the clipboard. It also exposes a UI for editing ImageOptions, including placeholder colors, rounding, borders, and scale types. The tool is backed by concurrency-safe tracking and includes tests for UI utilities and concurrent access.

vito/tools/liveeditor · high confidence

New Zoomable sample app with swipe and double-tap controls

A new sample application demonstrates the ZoomableVitoView component within a ViewPager, allowing users to swipe between images. The sample includes a menu option to toggle whether swiping is permitted while an image is zoomed in, and configures the view to support double-tap-to-zoom gestures while disabling long-press interactions.

samples/zoomableapp/src/main/java · high confidence

New animated-webp module with unified WebP decoding and configurable bitmap formats

The animated-webp module introduces a new WebPImageDecoder that unifies image decoding by supporting both ByteBuffer and native memory pointers, and allows users to configure the Bitmap.Config for animated images via ImageDecodeOptions. The WebPImage class now implements the AnimatedImageDecoder interface, enabling direct decoding from native memory or byte buffers, while the WebpAnimationBackend handles frame rendering with proper scaling and temporary bitmap management. This change also includes updated copyright headers and license information.

animated-webp · high confidence

New data abstractions for scroll performance samples

The scroll performance sample now includes a new \Decorator\ interface and a \SimpleAdapter\ interface with utility methods. These additions allow the sample to support infinite scrolling scenarios by wrapping existing adapters with a decorator that ensures distinct URIs and handles empty states correctly, improving the robustness of the scrolling demonstration.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/data · high confidence

New data source abstractions for scroll performance sample

The scroll performance sample now includes a \DistinctUriDecorator\ that appends a unique query parameter to URIs to ensure distinctness for infinite adapters, and a \LocalResourceSimpleAdapter\ that loads image URIs from string arrays with optional lazy initialization.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/data/impl · high confidence

New debug data providers for image fit ratio and wasted memory

The Vito debug overlay now includes new data providers that visualize the image-to-drawable (I:D) fit ratio and calculate wasted memory usage. These additions allow developers to quickly identify performance issues, such as oversized images consuming excessive memory, by displaying color-coded indicators (green for optimal, yellow for slightly oversized, and red for significant waste or poor fit) directly in the debug view.

core-common-impl · high confidence

New debug overlay displays image metadata and loading performance

A new debug overlay drawable has been added to the Drawee library that renders debug information directly onto images. This overlay displays key image metadata including the controller ID, image ID, dimensions, format, scale type, and animation details (frame/loop counts). It also visualizes loading performance by showing the final image load time and allows for color-coded feedback based on image size accuracy (green for OK, yellow for slight deviation, red for significant deviation). The overlay supports configurable text gravity, custom color shades, and additional arbitrary key-value data, providing developers with immediate visual feedback on image loading and properties during development.

drawee/src/main/java/com/facebook/drawee/debug · high confidence

New image performance logging and listener interfaces in ui-common

The ui-common module now exposes a new image performance logging system, including the ImagePerfDataListener interface and supporting classes like ImagePerfData, ImagePerfState, and ImagePerfNotifier, which allow external consumers to receive detailed updates on image load status and visibility changes. This is accompanied by a new ControllerListener2 interface with an Extras data class for passing rich context (such as viewport dimensions, scale type, and smart URL modification results) through the image loading lifecycle, along with a thread-safe ForwardingControllerListener2 to manage multiple listeners. Additionally, the module introduces a PrefetchData class for prefetch telemetry, a DimensionsInfo data class with proper equals/hashCode implementations, and new ImageLoadStatus values like FALLBACK\_RENDERED and RELEASED to provide more granular status reporting.

ui-common/src/main/java · high confidence

New image performance monitoring and origin tracking

The drawee-pipeline module now includes a new image performance monitoring system that tracks image load origins (such as network, disk, memory, or local sources) and reports detailed performance data. This change introduces the ImageOrigin enum and listener interfaces to identify where images are sourced from, and adds the ImagePerfMonitor to collect metrics like on-screen dimensions and load status, notifying registered listeners about image loading events and visibility changes.

drawee-backends/drawee-pipeline/src/main/java/com/facebook/drawee/backends/pipeline/info · high confidence

New image scaling and sizing hint APIs in ui-core

The ui-core module now exposes a new \ScalingUtils\ class and \ScaleType\ interface for calculating image scaling transformations, including a new \DISABLED\ scale type and support for focus-point-based cropping (\FOCUS\_CROP\). Additionally, a \SizingHint\ enum has been added to allow specifying quality vs. loading speed trade-offs (e.g., \LOWEST\_QUALITY\_FASTEST\_LOADING\), and a \Viewport\ data class now bundles width, height, scale type, and sizing hint for use in viewport-aware prefetching.

ui-core/src/main/java/com · high confidence

New lightweight debug overlay and performance logging for Vito v2

This change introduces a new lightweight debug overlay for Vito v2 images, visible when debug mode is enabled. The overlay displays a color-coded bar at the bottom of the image to indicate the image origin (green for memory/local, yellow for disk/encoded, red for network) and shows key performance metrics like image dimensions and wasted memory. Additionally, it logs detailed image fit ratio and wasted memory data to logcat (tagged as 'ImageFitRatio') for programmatic capture, helping developers identify performance issues related to image sizing and memory usage.

vito/core-common-impl/src/main · high confidence

New native JPEG transcoder module for Android

A new \native-imagetranscoder\ module has been introduced to handle JPEG transcoding using native code and libjpeg-turbo. This module provides a Java/Kotlin API (\NativeJpegTranscoder\) and factory (\NativeJpegTranscoderFactory\) that wraps the native library, enabling image resizing, rotation (including EXIF-based rotation), and quality adjustment. The native layer manages JNI bindings, custom error handling to prevent process crashes on corrupt images, and stream wrappers for efficient I/O. It also includes unit tests for the native error handling logic and updates the build configuration to use \c++\_static\ and flexible page sizes.

native-imagetranscoder · high confidence

New native image filters for blur and rounding

A new native-filters module has been added to Fresco, providing high-performance, native C++ implementations for image transformations. This includes an iterative box blur filter (approximating Gaussian blur) and rounding filters that can convert bitmaps to circles or apply rounded corners with optional anti-aliasing and borders. These native capabilities are exposed to the Android image pipeline via new Kotlin post-processors—\IterativeBoxBlurPostProcessor\, \RoundAsCirclePostprocessor\, and \RoundedCornersPostprocessor\—allowing developers to apply these effects efficiently during image decoding and caching.

native-filters · high confidence

New property delegates for automatic resource cleanup

Added AutoCleanupDelegate and AutoCloseableDelegate Kotlin property delegates to the fbcore library. These allow properties to automatically invoke a cleanup function (such as closing a resource) when their value changes or is set to null, simplifying resource management in code.

fbcore/src/main/java/com/facebook/common/closeables · high confidence

New utility classes for animation sample apps

Added three new utility classes to the animation2 sample: AnimationBackendUtils provides a helper to wrap animation backends with an inactivity check that shows a toast after 2 seconds of no frames; AnimationControlsManager manages standard playback controls (play/pause toggle, reset button, and seekbar) for AnimatedDrawable2 instances; and SampleAnimationBackendConfigurator sets up a spinner UI to let users switch between sample animation backends (color, local drawables, and bitmap).

samples/animation2/src/main/java/com/facebook/samples/animation2/utils · high confidence

Open-source gesture detection components for multi-touch interactions

The gesture sample module now includes the \MultiPointerGestureDetector\ and \TransformGestureDetector\ classes, which were previously internal or closed-source. \MultiPointerGestureDetector\ handles the low-level tracking of up to two touch pointers, while \TransformGestureDetector\ builds on top of it to expose high-level translation, scale, and rotation values to application listeners. These components are now available for use in samples and potentially other parts of the codebase, providing a standardized way to detect and react to complex multi-touch gestures.

samples/gestures/src/main/java · high confidence

Resizable image preview widget for the Showcase app

The Showcase sample app now includes a new ResizableFrameLayout widget that allows users to interactively resize image previews via touch gestures. This component supports drag-to-resize functionality with configurable maximum dimensions and minimum size constraints, and notifies listeners when the preview size changes, enhancing the interactive experience of the image pipeline samples.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imagepipeline/widget · high confidence

Sample app demonstrates configurable bitmap frame preparation

The animation2 sample app now includes an ExampleBitmapAnimationFactory that showcases the new BitmapFramePreparer and FixedNumberBitmapFramePreparationStrategy components. This allows users to see how to configure a specific number of frames to be prepared in advance (set to 3 in the sample) and how to wire up a custom executor for frame preparation, providing a concrete example of optimizing animation performance through pre-caching.

animation2 · high confidence

Scrollperf sample app adds utility classes for Vito image options and UI configuration

The scrollperf sample app introduces several new utility classes in the \util\ package to support the Vito image pipeline. \VitoUtil\ now constructs \ImageOptions\ with support for rounded corners, borders, and various scale types based on the app's configuration. \PipelineUtil\ manages post-processing (including slow and fast delay postprocessors) and rotation options (auto-rotate or forced angle). \SizeUtil\ handles view resizing and display metrics, while \UI\ provides helper methods for finding views by ID. \TimeWaster\ includes a Fibonacci calculation method for performance testing.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/util · high confidence

Showcase app adds SVG support toggle and decoder example

The Showcase sample app now includes a dedicated SVG image format section. Users can enable or disable SVG decoding via a toggle switch, which prompts a restart warning when changed. The sample also provides a complete example implementation of an SVG decoder, format checker, and drawable factory, demonstrating how to integrate custom image format support into Fresco.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/svg · high confidence

Showcase app adds custom scale types and UI helper utilities

The Showcase sample app now includes examples for custom image scaling behaviors (fit\_x and fit\_y) alongside the standard built-in scale types, allowing users to see how custom ScalingUtils implementations work. To support these new samples, the common module introduces a SimpleScaleTypeAdapter for displaying scale options in spinners, Kotlin extension functions in SpinnerUtils for configuring spinners with data or callbacks, and DimensionUtils for converting DP to pixels.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/common · high confidence

Showcase app adds image pipeline samples for resizing, post-processing, and prefetching

The Showcase sample app now includes new fragments demonstrating direct ImagePipeline usage: ImagePipelineResizingFragment allows users to test various resize options and image formats; ImagePipelinePostProcessorFragment showcases post-processing effects like greyscale, blur, and watermarks with performance timing; ImagePipelinePrefetchFragment demonstrates prefetching to disk, encoded, and bitmap caches; ImagePipelineBitmapFactoryFragment illustrates bitmap creation and manipulation; ImagePipelineDownsampleFragment shows downsample mode selection; ImagePipelineNotificationFragment provides a notification image example; ImagePipelineQualifiedResourceFragment displays qualified resources; and PartialRequestFragment demonstrates partial image loading. These samples are built using the VitoView component.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imagepipeline · high confidence

Showcase app adds post-processor samples and benchmark helpers

The Showcase sample app now includes new post-processor examples and utilities. It introduces benchmark helpers (BenchmarkPostprocessorForDuplicatedBitmap, BenchmarkPostprocessorForDuplicatedBitmapInPlace, BenchmarkPostprocessorForManualBitmapHandling) that wrap existing post-processors to measure and report their processing duration via a DurationCallback. It also adds sample post-processors: a cached watermark (CachedWatermarkPostprocessor) that ensures consistent output by providing a stable cache key, and a comparison of grayscale implementations (SlowGreyScalePostprocessor using per-pixel JNI calls vs. FasterGreyScalePostprocessor using bulk pixel arrays) to illustrate performance differences.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/postprocessor · high confidence

Showcase app adds settings for cache management, URI overrides, and device details

The Showcase sample app now includes a Settings screen that allows users to clear the Fresco disk cache, override image URIs via a dialog, and view device information such as Android version, CPU architecture, and device name.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/settings · high confidence

Showcase app receives new utility components and a welcome screen

The Showcase sample app now includes a new WelcomeFragment that displays the Fresco logo and provides buttons to open the documentation and GitHub repository. To support varied testing scenarios, the app introduces an ImageUriProvider utility for managing sample image URIs (including support for custom local images, media store URIs, and GIFs) and an ImageSourceSpinner UI component to let users select image sources. Additionally, a CheckerBoardDrawable is added to help visualize image transparency, and a LogcatImagePerfDataListener is provided to log image loading and visibility performance data for debugging.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/misc · high confidence

Showcase app restructured with Vito examples and modernized setup

The Fresco Showcase sample app has been significantly reorganized to highlight the new Vito image rendering engine. The navigation is now driven by a centralized ExampleDatabase, grouping samples into categories like Image Pipeline, Image Formats, and dedicated sections for Fresco Vito and the Vito Renderer. The app has been migrated to Kotlin, replacing legacy Drawee-based samples with Vito-specific demonstrations such as Litho components, VitoView usage, and shared element transitions. Additionally, the app now supports custom image format decoders (SVG, color, keyframes) and includes a toolbar dropdown to switch window color modes (Normal, P3, HDR) on supported devices.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase · high confidence

Showcase sample adds GIF playback with autoplay and decoder selection

The Showcase sample app now includes a dedicated GIF example that demonstrates animated image playback. Users can toggle autoplay on or off, switch between different GIF sizes via a spinner, and choose between the default decoder and a custom GifLite decoder. The sample also allows toggling a checkerboard background and adjusting aspect ratio, providing a practical reference for integrating GIF support in Android apps.

samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/imageformat/gif · high confidence

Unified animated image rendering and caching infrastructure

The animated-base module now provides a consolidated foundation for rendering and caching animated images (GIF/WebP). It introduces a new \AnimatedImageDecoderBase\ to standardize frame decoding and preview generation, and a dedicated \FrescoFrameCache\ to manage frame memory with optional bitmap reuse. Rendering is handled by \AnimatedDrawableBackendFrameRenderer\ which delegates to the \AnimatedImageCompositor\, while \AnimatedFactoryV2Impl\ and \DefaultBitmapAnimationDrawableFactory\ orchestrate the creation of \AnimatedDrawable2\ instances. This change also includes utilities for frame timing validation and animation backend abstraction.

animated-base · high confidence

Zoomable sample library open-sourced with animation, gesture, and listener enhancements

The zoomable sample code in the \samples/zoomable\ directory is now open-source, introducing a new \AbstractAnimatedZoomableController\ that enables smooth animated zooming to specific points and transforms. The \DefaultZoomableController\ has been expanded to support granular gesture control, allowing developers to disable specific gestures (rotation, scale, translation, or gesture-based zoom) and exposing an \ImageBoundsListener\ for bounds notifications. Touch handling has been refined with a new \DoubleTapGestureListener\ for double-tap-to-zoom and double-tap-drag-to-zoom interactions, while the \ZoomableController.Listener\ interface now provides \onTransformBegin\ and \onTransformEnd\ callbacks. Additionally, \ZoomableDraweeView\ and the new \ZoomableVitoView\ support configurable touch interception for parent views (like ViewPagers) and allow setting custom tap listeners, with \ZoomableDraweeView\ marked as deprecated in favor of \VitoView\.

samples/zoomable/src/main/java · high confidence

Removals

Removal of ObjectPool component from fbcore

The generic object pooling implementation, including the ObjectPool class, its builder, and the ObjectPoolManager, has been removed from the fbcore library. This eliminates the ability to create, manage, and reuse pooled object instances via the previous API, requiring consumers to adopt alternative memory management or pooling strategies.

fbcore/src/main/java/com/facebook/common/objectpool · high confidence

Removal of OkHttp 2 backend support

The OkHttp 2 integration has been removed from the image pipeline. The \OkHttpImagePipelineConfigFactory\ and \OkHttpNetworkFetchProducer\ classes, which previously facilitated network fetches using the \com.squareup.okhttp\ library (OkHttp 2), have been deleted. Users relying on this specific backend implementation will no longer have access to these components and should upgrade to a newer version of the library or copy the code if needed.

imagepipeline-backends/imagepipeline-okhttp · high confidence

Removal of Volley Drawee backend module

The Volley integration for the Drawee image loading library has been removed. This change deletes the \VolleyDataSource\, \VolleyDraweeController\, \VolleyDraweeControllerBuilder\, \VolleyDraweeControllerBuilderSupplier\, and \VolleyDraweeControllerFactory\ classes, effectively eliminating the ability to use Volley as a data source backend for Drawee images.

drawee-backends/drawee-volley · high confidence

Removal of legacy sample app and instrumentation code

The sample application, including its main activity, image-loading adapters for Fresco, Glide, Picasso, UIL, and Volley, configuration factories, and instrumentation classes for performance tracking, has been removed from the codebase.

sample · high confidence

Architecture

Extract Vito core implementation to new core-java-impl module

The Vito image loading core implementation has been extracted into a new \core-java-impl\ module. This change introduces the foundational classes for the Vito pipeline, including \FrescoController2Impl\ for managing image requests and drawable states, \FrescoDrawable2\ and \FrescoDrawable2Impl\ for handling the visual representation and layer management (placeholders, progress, overlays), and \HierarcherImpl\ for constructing drawable hierarchies. It also includes \FrescoVitoPrefetcherImpl\ for preloading images to memory or disk caches, \ImageSourceToImagePipelineAdapter\ for bridging image sources to the pipeline, and \ImagePipelineUtilsImpl\ for building image requests with proper decode options. A new \AndroidManifest.xml\ is added to define the module's package.

vito/core-java-impl/src/main · high confidence

Behavioural changes

Activity listeners now execute in deterministic priority order

The ActivityListener interface now includes a getPriority() method (with a default of MIN\_PRIORITY in BaseActivityListener), allowing listeners to specify an execution order. Listeners with higher priority values are fired first, ensuring deterministic behavior when multiple listeners are registered for the same activity lifecycle events.

fbcore/src/main/java/com/facebook/common/activitylistener · high confidence

Add Stetho instrumentation and Android 13+ permission support to the comparison sample

The comparison sample app now includes Stetho debugging support, initializing the Stetho client with the FrescoStethoPlugin to allow developers to inspect image pipeline requests and cache state via Chrome DevTools. Additionally, the app has been updated to handle Android 13+ storage permissions correctly by requesting READ\_MEDIA\_IMAGES on TIRAMISU+ devices, ensuring the sample functions on modern Android versions without permission crashes.

samples/comparison/src/main/java/com/facebook/samples/comparison · high confidence

Added ProGuard configuration for the Showcase sample app

The Showcase sample app now includes dedicated ProGuard rules files (proguard-showcase.pro and proguard-test.pro) to manage code shrinking and obfuscation. These files define keep rules for specific third-party libraries such as AndroidSVG, Flipper, and LeakCanary, and suppress warnings for various Android and Facebook internal classes, ensuring the sample builds correctly with minification enabled.

samples/showcase · high confidence

Added ProGuard configuration with license header

The samples/comparison module now includes a proguard.pro file that applies the MIT license header and adds a rule to suppress warnings for the com.squareup.picasso library, ensuring cleaner build outputs for this sample.

samples/comparison · high confidence

Added SoLoader initialization delegate

A new NativeCodeInitializer class and AndroidManifest have been added to the soloader module. This initializer provides a delegate method to properly set up and initialize SoLoader, ensuring native code loading is correctly configured for the application.

soloader · high confidence

Animated GIF support is now a standalone module with a new validation layer

The animated GIF decoding logic has been extracted from the image pipeline into a dedicated \animated-gif\ module. This change introduces a new \AnimatedImageGifValidator\ that checks GIF dimensions and total pixel count before decoding, preventing crashes from oversized or malformed images. The module also includes a refactored JNI layer with improved memory safety (bounds checking), support for file descriptors, and updated build configurations for modern NDK toolchains.

animated-gif · high confidence

Centralized build configuration and dependency management via buildSrc

The project has migrated its build configuration into the buildSrc module, introducing centralized Kotlin objects (FrescoConfig, GradleDeps, TestDeps, SampleDeps, and Deps) to manage SDK versions, build tools, and third-party dependencies. This change updates the Android Gradle Plugin to 9.2.1, Kotlin to 2.2.0, and NDK to r28c, while setting the compile SDK to 34 and minimum SDK to 21 for core components. It also consolidates dependency definitions for libraries such as Litho (0.50.1), SoLoader (0.11.0), Flipper (0.240.0), and various AndroidX and testing libraries, ensuring consistent versioning across the Fresco codebase and sample apps.

buildSrc · high confidence

CircularBitmapTransformation now supports fast native rounding and correct equality checks

The new CircularBitmapTransformation in the nativecode module allows users to opt into a faster bitmap rounding path via the useFastNativeRounding flag, which delegates to NativeRoundingFilter.toCircleFast instead of the standard toCircle method. Additionally, the class now implements explicit equals and hashCode methods based on its configuration properties (isAntiAliased and useFastNativeRounding), ensuring correct behavior when instances are compared or used in collections.

nativecode · high confidence

Clock APIs now provide nanosecond-precision timestamps

The time library has been unified to support nanosecond-precision monotonic clocks. The \MonotonicClock\ interface now exposes a \nowNanos()\ method, and existing implementations like \RealtimeSinceBootClock\ and the new \AwakeTimeSinceBootClock\ provide this precision (with \AwakeTimeSinceBootClock\ recommended for performance logging as it stops during sleep). To maintain backward compatibility, the existing millisecond-based \now()\ method is now a default implementation derived from \nowNanos()\. Additionally, several legacy utility classes (\TimeConstants\, \TimeConversions\, \TimeSpan\, \TimeUtil\) have been removed, and all clock classes have been updated with null-safety annotations and the MIT license.

fbcore/src/main/java/com/facebook/common/time · high confidence

Comparison sample adapters migrated to RecyclerView

The comparison sample app's image loading adapters (AQuery, Fresco, Glide) have been refactored to use RecyclerView instead of ListView. This change introduces a new base ImageListAdapter class and specific adapter implementations for each library, enabling more efficient list rendering and allowing the sample to support multiple image loading libraries side-by-side for performance comparison.

samples/comparison/src/main/java/com/facebook/samples/comparison/adapters · high confidence

Comparison sample holders migrate to RecyclerView and VitoView

The comparison sample's view holders have been refactored to extend a new BaseViewHolder that integrates with RecyclerView instead of ListView, and the Fresco implementation now uses VitoView (via ImageSourceProvider) instead of the legacy DraweeView. New holder classes have been added for Android Query (AQuery), and existing holders for Glide, Picasso, Universal Image Loader, and Volley have been updated to align with this new base class and instrumentation setup.

samples/comparison/src/main/java/com/facebook/samples/comparison/holders · high confidence

Configurable image pipeline settings for the comparison sample app

The comparison sample app now uses a dedicated ImagePipelineConfigFactory to configure image loading. This includes enabling downsampling (set to ALWAYS), setting specific limits for memory and disk caches, adding request logging, and integrating Stetho for network debugging when using OkHttp.

samples/comparison/src/main/java/com/facebook/samples/comparison/configs/imagepipeline · high confidence

Core utility classes migrated from Java to Kotlin

The \ByteConstants\, \HashCodeUtil\, \Hex\, \SecureHashUtil\, \StreamUtil\, and \UriUtil\ classes in \fbcore/src/main/java/com/facebook/common/util\ have been rewritten from Java to Kotlin. This migration updates the codebase to use Kotlin idioms (such as \object\ for singletons and \const val\ for constants) and modernizes the license headers from BSD to MIT. Additionally, the \TriState\ enum has been updated with \@Nullsafe\ annotations and \@Functional\ markers to support null-safety and functional programming patterns within the core utilities.

fbcore/src/main/java/com/facebook/common/util · high confidence

DataSource API enhancements and Kotlin migration

The DataSource abstraction in fbcore has been updated with several new capabilities and structural changes. A new \RetainingDataSourceSupplier\ allows retaining data sources for scenarios like GIF playback, while \SimpleDataSource\ and \SuccessfulVoidDataSource\ provide simpler ways to create settable and immediate data sources. The \DataSource\ interface now supports extras via \getExtras()\, progress tracking via \getProgress()\, and multiple results via \hasMultipleResults()\. Utility methods in \DataSources\ include \waitForFinalResult\ for blocking on results with optional timeouts, and \immediateDataSource\/\immediateFailedDataSource\ for creating pre-set sources. \BaseDataSubscriber\ now handles progress updates and fixes a race condition by checking \isFinished()\ before closing. The old \SettableDataSource\ has been removed in favor of \SimpleDataSource\, and the codebase has been migrated to Kotlin for new classes and annotated with \@Nonnull\ and \@Nullsafe\ for better compatibility.

fbcore/src/main/java/com/facebook/datasource · high confidence

Disables Mockito class cache to prevent compatibility bugs

The mockito-config module now includes a custom MockitoConfiguration that disables the class cache by overriding enableClassCache() to return false. This change is intended to prevent bugs arising from interactions between Mockito and Robolectric. The configuration class is annotated with @Nullsafe(Nullsafe.Mode.LOCAL) and carries the updated Meta copyright header.

mockito-config · high confidence

Disk trimmable interfaces migrated to Kotlin

The \DiskTrimmable\, \DiskTrimmableRegistry\, and \NoOpDiskTrimmableRegistry\ components in \fbcore\ have been rewritten from Java to Kotlin. This migration updates the license headers to MIT and changes the copyright holder to Meta. For users, the functional behavior remains the same: \DiskTrimmable\ still defines the contract for classes needing to trim disk usage, \DiskTrimmableRegistry\ manages the list of such classes, and \NoOpDiskTrimmableRegistry\ provides a no-operation implementation. The Kotlin version of \NoOpDiskTrimmableRegistry\ is now a singleton object, replacing the previous Java singleton pattern.

fbcore/src/main/java/com/facebook/common/disk · high confidence

Drawee components rewritten in Kotlin with concurrency and configuration improvements

The Drawee components in this package have been migrated from Java to Kotlin. The \DeferredReleaser\ implementation is now thread-safe, allowing deferred resource releases to be scheduled from background threads without crashing, and it safely cancels pending releases if an attach event occurs before the release executes. The \DraweeEventTracker\ now includes a \disable()\ method, allowing users to turn off internal event recording for debugging before initializing Fresco. Additionally, the \RetryManager\ exposes a \setMaxTapToRetryAttempts\ method, enabling developers to configure the maximum number of tap-to-retry attempts beyond the default of four.

drawee/src/main/java/com/facebook/drawee/components · high confidence

Drawee drawable classes migrated to Kotlin

The core drawable implementations in the Drawee module (including FadeDrawable, ScaleTypeDrawable, RoundedBitmapDrawable, OrientedDrawable, MatrixDrawable, ProgressBarDrawable, and related utilities) have been rewritten from Java to Kotlin. This migration introduces null-safety annotations, refactors property handling (such as the new DrawableProperties wrapper for alpha and color filters), and adds new capabilities like the CloneableDrawable interface and configurable repeat-edge pixels for rounded images, while maintaining the same public API for existing users.

drawee/src/main/java/com/facebook/drawee/drawable · high confidence

Drawee initialization and configuration overhaul

Fresco's initialization now enforces a single-call constraint with a warning if initialized more than once, always uses the Application Context to prevent memory leaks, and integrates NativeLoader initialization with systrace markers. DraweeConfig introduces support for custom Drawable factories, a dynamic debug overlay toggle via Supplier, and a default ImagePerfDataListener for performance monitoring. PipelineDraweeControllerBuilder now supports multiple controller listeners (ControllerListener2), automatically applies auto-rotation to URIs, and passes cache keys and custom factories to the controller. PipelineDraweeControllerFactory decouples controller creation from initialization, accepts XML drawable factories, and wires up memory cache and debug overlay settings.

drawee-backends/drawee-pipeline/src/main/java/com/facebook/drawee/backends/pipeline · high confidence

Drawee interfaces updated with accessibility, viewport, and null-safety improvements

The Drawee framework interfaces have been enhanced to support better accessibility and performance awareness. DraweeController now exposes methods to set and retrieve an accessibility content description and provides a viewport visibility hint to allow controllers to optimize resource usage when images are off-screen. Additionally, DraweeHierarchy exposes the bounds of the top-level drawable, and the controller interface now includes an equality check based on the image request. The interfaces are also marked as thread-safe and annotated with local null-safety, while progress parameters in SettableDraweeHierarchy have been standardized to float values.

drawee/src/main/java/com/facebook/drawee/interfaces · high confidence

Enhanced disk space monitoring with new thresholds and detailed usage metrics

StatFsHelper now exposes new constants for disk space thresholds (yellow, red, and olive levels) and provides new methods to retrieve specific free and total storage space in bytes. The class has also been updated to use modern Android APIs for block size and count retrieval, and its null-safety annotations have been adjusted to LOCAL mode.

fbcore/src/main/java/com/facebook/common/statfs · high confidence

Executor services marked null-safe and UiThreadExecutorService removed

The executor classes in fbcore (including CallerThreadExecutor, ConstrainedExecutorService, HandlerExecutorServiceImpl, and StatefulRunnable) are now annotated with @Nullsafe(Nullsafe.Mode.LOCAL) to enforce null-safety checks, and the UiThreadExecutorService class has been removed from the library.

fbcore/src/main/java/com/facebook/common/executors · high confidence

Expanded memory trim levels and new buffer utilities in fbcore

The memory management API in fbcore now supports finer-grained memory pressure handling by introducing new MemoryTrimType values, including critical and moderate foreground/background states, UI-hidden events, and address-space red states. To support these changes, the PooledByteBuffer interface and its associated factory, output stream, and byte stream utilities have been moved from the imagepipeline module to fbcore to resolve circular dependencies. Additionally, a new DecodeBufferHelper class provides a thread-local ByteBuffer pool for decoding operations, and existing memory-related classes have been annotated for null-safety.

fbcore/src/main/java/com/facebook/common/memory · high confidence

FLog logging wrapper migrated to Kotlin with ProGuard optimization and API simplification

The FLog logging utility has been rewritten from Java to Kotlin, introducing null-safety annotations and exposing static members via @JvmField for better Java interoperability. To improve release build performance, a ProGuard rule has been added to strip verbose, debug, and info logging calls. The public API has been simplified by removing the tag-based isLoggable check from the LoggingDelegate interface, and internal stack-trace generation now uses the more efficient Log.getStackTraceString method.

fbcore/src/main/java/com/facebook/common/logging · high confidence

File utilities adopt null-safety annotations and update licensing

The file utility classes in fbcore now include null-safety annotations, with FileTree marked as locally null-safe and the RenameException constructor accepting a nullable inner exception, improving static analysis support for developers. Additionally, the codebase has migrated its license headers from the BSD-style Facebook license to the MIT license and updated copyright notices to Meta Platforms, Inc. and affiliates.

fbcore/src/main/java/com/facebook/common/file · high confidence

Glide image loading configuration updated for the comparison sample

The Glide configuration in the comparison sample app has been updated to version 4.7.1. A new SampleGlideModule is introduced to explicitly set disk and memory cache sizes using ConfigConstants and to disable manifest parsing, ensuring consistent image loading behavior within the sample environment.

samples/comparison/src/main/java/com/facebook/samples/comparison/configs/glide · high confidence

Internal utility classes marked as null-safe and simplified

The internal utility classes in fbcore (such as Preconditions, Objects, ByteStreams, and Closeables) are now annotated with @Nullsafe(LOCAL), enabling null-safety checks within this module. Additionally, several Guava-derived utility classes (Ints, Lists, Maps, VisibleForTesting) have been removed, and new dummy implementations for ImmutableList, ImmutableSet, and ImmutableMap have been added to provide temporary type support without Guava dependencies.

fbcore/src/main/java/com/facebook/common/internal · high confidence

Introduces Kotlin-based extras infrastructure and utility for image pipeline data

The middleware layer now uses a new Kotlin interface, HasExtraData, to define a standardized set of keys for passing metadata (such as image format, viewport dimensions, and SmartFetch details) through the image pipeline. A corresponding utility class, MiddlewareUtils, provides a helper method to aggregate various component and data source attributes into a unified extras object, replacing previous Java implementations with this new Kotlin-based structure.

middleware/src/main/java · high confidence

Java stream utilities migrated to Kotlin

The \LimitedInputStream\ and \TailAppendingInputStream\ classes in \fbcore\ have been rewritten from Java to Kotlin. This migration updates the implementation language while preserving the existing behavior: \LimitedInputStream\ now restricts reads to a specified byte limit, and \TailAppendingInputStream\ appends a fixed byte sequence after the underlying stream is exhausted. Users consuming these utilities will see no functional change, but the codebase benefits from Kotlin's null-safety and idiomatic syntax.

fbcore/src/main/java/com/facebook/common/streams · high confidence

License migration to MIT and adoption of Contributor Covenant

The project has switched its licensing from BSD to the MIT License, removing the previous separate patent grant file and updating the README to reflect the new license and copyright holder (Meta Platforms). Additionally, a Code of Conduct based on the Contributor Covenant has been added to establish community standards, and the contributing guide has been updated to reflect the main branch, NDK setup, and security disclosure processes.

(repo-wide) · high confidence

Migrate Fresco Stetho plugin to Kotlin and refactor cache inspection

The Fresco Stetho plugin implementation in \tools/stetho/src/main/java\ has been rewritten from Java to Kotlin. This change introduces a \BaseFrescoStethoPlugin\ that centralizes cache inspection logic (memory and disk) and a concrete \FrescoStethoPlugin\ that initializes using the global Fresco factory. The migration includes refactoring the disk cache inspection to use the new \DiskCachesStore\ supplier pattern, ensuring consistent access to main and small image file caches for dump commands.

tools/stetho/src/main/java · high confidence

Migrate Vito core image listener classes to Kotlin

The image listener components in the Vito core module (ImageListener interface, BaseImageListener, and ForwardingImageListener) have been rewritten from Java to Kotlin. This migration preserves the existing public API and behavior for image status callbacks, ensuring that applications relying on these listeners continue to function without code changes while benefiting from Kotlin's language features.

vito/core/src/main/java/com/facebook/fresco/vito/listener · high confidence

Migrate drawable factory logic to Kotlin

The drawable creation and rendering logic in the Vito core module has been rewritten in Kotlin. This migration introduces new implementations for handling bitmap drawables, including support for circular borders via CircularBorderBitmapDrawable, and refactors the rounding and border application utilities in RoundingUtils. The ArrayVitoDrawableFactory now uses Kotlin's firstNotNullOfOrNull for factory chaining, and BitmapDrawableFactory handles rotation and EXIF orientation using OrientedDrawable, ensuring existing image display behaviors are preserved in the new language implementation.

vito/core/src/main/java/com/facebook/fresco/vito/drawable · high confidence

Migrate options classes to Kotlin and implement custom equality

BorderOptions, RoundingOptions, and the new AnimatedOptions are now implemented in Kotlin as data classes with manually defined equals and hashCode methods to ensure correct value-based comparison. This migration includes adding a disableAnimation toggle and loop count support to AnimatedOptions for controlling animated image playback, and updating RoundingOptions to support anti-aliasing parameters in its factory methods.

options · high confidence

Migrated Fresco Vito provider to Kotlin with new initialization architecture

The Fresco Vito provider module has been rewritten in Kotlin, introducing a new \FrescoVitoSetup\ interface and a \FrescoVitoComponents\ singleton to manage the provider implementation. This change adds a \DefaultFrescoVitoProvider\ and a \KFrescoVitoProvider\ (which uses \KFrescoController\), enabling support for animated images, vector drawables, and global image performance listeners. The migration also includes a fix for a NullPointerException in the default drawable factory creation and adds a lightweight debug overlay for Vito v2.

vito/provider · high confidence

Native circular bitmap rounding implementation added

A new nativecode module has been introduced to handle circular bitmap rounding using native code. This change adds a new AndroidManifest file defining the module's package and a Kotlin implementation class, NativeCircularBitmapRounding, which provides decode options for circular bitmap transformations with optional anti-aliasing, supporting a configurable fast native rounding mode.

vito/nativecode · high confidence

Native image pipeline code relocated to imagepipeline-native

The native C++ and JNI implementation for the image pipeline has been moved from the imagepipeline module to the new imagepipeline-native module. This change includes the relocation of core source files (such as Bitmaps.c, init.cpp, and exceptions.cpp) and their associated build scripts (Android.mk, Application.mk), along with updated copyright headers reflecting the transition to Meta. For users, this represents a structural reorganization of the library's native components without altering the exposed Java API or runtime behavior.

imagepipeline-native/src/main/jni/imagepipeline · high confidence

New centralized configuration system for Scroll Perf sample app

The Scroll Perf sample app now uses a new \Config\ class and \Const\ constants to manage settings via Android SharedPreferences. This change introduces support for configuring data sources (local, webp, png, infinite, distinct URIs), layout types (ListView, RecyclerView, Grid), image rendering options (rounded corners, postprocessors, scale type, rotation, downsampling, size override, fade duration, border), and performance/debugging toggles (decoding threads, cancellation, Vito overlay, instrumentation).

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/conf · high confidence

OkHttp backend rewritten in Kotlin with support for both OkHttp 3.x and 4.x

The Fresco OkHttp imagepipeline backend has been converted from Java to Kotlin. This change introduces a compatibility layer (OkHttpCompat.kt) that allows the backend to function with both OkHttp 3.x and 4.x by using extension properties to bridge API differences, making the backend version-agnostic. The core network fetching logic (OkHttpNetworkFetcher) and configuration factory (OkHttpImagePipelineConfigFactory) are now implemented in Kotlin, providing the same functionality while improving maintainability and enabling future Kotlin-specific features.

imagepipeline-backends/imagepipeline-okhttp3/src/main/java · high confidence

Picasso sample app now uses OkHttp3 for image loading

The Picasso configuration in the comparison sample app has been updated to use OkHttp3 as the network downloader. This change allows the sample to leverage OkHttp3's capabilities for fetching images, providing a more modern networking stack for the Picasso integration test.

samples/comparison/src/main/java/com/facebook/samples/comparison/configs/picasso · high confidence

Refactored CloseableReference to support pluggable reference-counting strategies and leak detection

The reference management system in fbcore has been restructured to allow different implementation strategies for CloseableReference, including Default, Finalizer-based, RefCount, and NoOp variants. This change introduces a configurable LeakHandler interface that enables custom reporting of unclosed resources, replacing the previous hardcoded logging behavior. Additionally, the system now supports skipping bitmap recycling for NoOp references via an A/B test flag, and updates copyright headers from Facebook to Meta across the package.

fbcore/src/main/java/com/facebook/common/references · high confidence

Refactored Drawee hierarchy structure and enhanced rounding capabilities

The Drawee hierarchy implementation has been restructured to use a dedicated RootDrawable as the top-level container, replacing the previous RootFadeDrawable, which improves visibility management and prevents erroneous scaling based on intrinsic dimensions. The hierarchy inflation logic has been extracted into a new GenericDraweeHierarchyInflater class, simplifying the builder and allowing for easier customization of default values. Additionally, rounding support has been expanded with new options in RoundingParams, including the ability to repeat edge pixels for smaller images, set border colors separately from width, and apply rounding to background drawables. The hierarchy now also supports dynamic changes to rounding parameters and backgrounds without requiring a full rebuild.

drawee/src/main/java/com/facebook/drawee/generic · high confidence

Refactored image performance state management and request listening

The internal image performance tracking logic has been restructured: the previous listener interface was replaced by ImagePerfRequestListener to capture request-level timing, and the controller listener was renamed to ImagePerfStateManager, which now manages ImagePerfState updates and notifies registered ImagePerfNotifier listeners on status changes. Additionally, the load status enum value AVAILABLE was renamed to SUCCESS to better reflect the final image load outcome.

drawee-backends/drawee-pipeline/src/main/java/com/facebook/drawee/backends/pipeline/info/internal · high confidence

Refactored image source architecture and added URI handling options

The Vito image source system has been restructured in Kotlin, introducing a new \ImageSource\ interface and a dedicated \ImageSourceProvider\ to create sources. This change adds support for passing extra metadata (extras) to the image pipeline, allows host apps to configure custom URI parsing logic, and introduces a new \treatEmptyUriAsImageSource\ flag to handle empty URIs gracefully instead of failing. Additionally, a \SmartFetchOptIn\ enum is provided to enable product-level control over Smart Fetch behavior.

vito/source/src/main/java · high confidence

Removal of SoLoaderShim abstraction layer

The \SoLoaderShim\ class, which previously provided an overridable interface for loading shared libraries via a configurable \Handler\, has been removed. Applications can no longer inject custom library loading logic through this shim; direct library loading via the standard \SoLoader\ mechanism is now required.

fbcore/src/main/java/com/facebook/common/soloader · high confidence

Scroll Perf sample app migrated to Vito with configurable postprocessing and executor settings

The Scroll Perf demo app has been updated to use the Vito rendering component, introducing new adapter and view holder classes (VitoViewAdapter, VitoViewHolder) to display images via RecyclerView. This migration includes the addition of a DelayPostprocessor, allowing users to simulate processing delays of varying lengths (fast, medium, slow) to test performance under different post-processing loads. Additionally, the app now features a custom ScrollPerfExecutorSupplier that allows configuration of decoding and CPU-bound thread counts, and uses a distinct executor for thumbnail production, providing more granular control over the image pipeline's threading behavior during performance testing.

scrollperf · high confidence

Scroll Perf sample app now uses Vito for image rendering

The Scroll Perf sample app has been migrated to use Vito for image rendering, replacing the previous Fresco-based implementation. This change introduces new UI fragments (MainFragment and SettingsFragment) and adapter classes (VitoViewAdapter, VitoViewListAdapter) that configure and display images using Vito's capabilities, including support for various data sources, layout types (RecyclerView, ListView, Grid), and image processing options like rounding, scaling, and post-processing.

samples/scrollperf/src/main/java/com/facebook/samples/scrollperf/fragments · high confidence

Showcase app restructured with new navigation and expanded Vito configuration options

The Showcase sample app has been refactored to use a new list-based navigation entry point (ShowcaseListActivity) that displays examples organized by category, replacing the previous initialization model with a decoupled dependency provider (ShowcaseProvider). This update introduces several new demonstration fragments, including region decoding for both ImagePipeline and Vito, and adds comprehensive configuration spinners in the Vito sample for rounding, borders, scale types, color filters, fading, placeholders, errors, progress indicators, and overlays. Additionally, new postprocessor examples (ScalingBlur, Watermark) and a LogcatRequestListener2 for debugging image requests are now included.

showcase · high confidence

Smooth scale type transitions and improved view lifecycle handling in Drawee views

GenericDraweeView now supports smooth animations when changing scale types (e.g., from FIT\_CENTER to CENTER\_CROP) via the new DraweeTransition class, which interpolates the image scaling during layout changes. Additionally, DraweeView and SimpleDraweeView now include legacy visibility handling to fix broken activity transitions on Android N and above, and DraweeHolder has been simplified by removing unreliable activity lifecycle listeners in favor of explicit attach/detach calls, making the views more robust in complex UI scenarios.

drawee/src/main/java/com/facebook/drawee/view · high confidence

Standardize CI build execution with a common script

The CI pipeline now uses a shared \ci/build-and-test.sh\ script to execute Gradle builds, allowing developers to run the same build commands locally with reduced verbosity by passing the \--local\ flag, while the standard CI environment retains maximum verbose output. Additionally, a new \ci/print-debug-info.sh\ script has been added to help diagnose environment issues by printing key configuration details like the PATH and ANDROID\_NDK\_HOME.

ci · high confidence

Standardize minimum SDK to API 21 and consolidate ProGuard rules

The fbcore module now requires a minimum SDK version of 21 (up from 9), with the previous manifest declarations removed in favor of Gradle-based configuration. Additionally, ProGuard optimization rules have been consolidated into a new dedicated file (proguard-fresco.pro) that preserves specific interfaces, native methods, and the SoLoader initialization, while suppressing warnings for several external libraries.

fbcore · high confidence

Static WebP decoder refactored into dedicated native module with sandboxing support

The static WebP decoding logic has been reorganized into a dedicated native module (static-webp) with a new build configuration (Android.mk) that links against libwebp 1.3.2. This change introduces a new DecodedImage abstraction to standardize pixel buffer handling and adds a Java exception-throwing helper to improve error propagation from native code to the Java layer. Additionally, the decoder now supports a sandboxed WebP decode path (via RLBOX) when enabled, and updates the Java class references to the animated WebP package.

static-webp/src/main/jni/static-webp · high confidence

The copyright headers in the gesture detection module have been updated to reflect Meta ownership and the MIT license. Additionally, the code now uses AndroidX's VisibleForTesting annotation and applies Nullsafe annotations (Mode.LOCAL) to improve static analysis and null-safety, including suppressing specific compiler warnings.

drawee/src/main/java/com/facebook/drawee/gestures · medium confidence

Updated Android NDK build configuration for static-webp

The static-webp native module now uses the clang toolchain and the c++\_static standard library, replacing the previous gnustl\_static implementation. The build also enables flexible page sizes and includes linker flags to garbage-collect unused sections and exclude static STL symbols, ensuring compatibility with newer NDK versions and reducing binary size.

static-webp/src/main/jni · high confidence

Vito core image loading and lifecycle APIs migrated to Kotlin

The Vito core image loading and lifecycle APIs have been rewritten in Kotlin, introducing new interfaces such as FrescoController2, FrescoDrawableInterface, and VitoImagePipeline to manage image fetching, drawable creation, and release strategies. This migration adds support for configurable release behaviors (immediate, delayed, next-frame) via FrescoVitoConfig, enables performance logging through ImagePerfLoggingListener and AnimatedImagePerfLoggingListener, and introduces a unified listener system with BaseVitoImageRequestListener and CombinedImageListener. The changes also add prefetching capabilities via FrescoVitoPrefetcher with configurable targets and reasons, and improve image handling with features like offer-back-on-release for memory cache reuse, dynamic size support, and better handling of empty image sources.

vito/core/src/main/java/com/facebook/fresco/vito/core · high confidence

Test coverage

Added Android instrumentation tests for WebP decoding; Added E2E test for the Fresco Showcase app launch; Added Kotlin tests for ControllerListenerWrapper; Added Kotlin tests for Vito image request and drawable rounding; Added Robolectric configuration for Android tests; Added and updated unit tests for common utility classes; Added test helper for BufferMemoryChunkPool; Added test helpers for AshmemMemoryChunk; Added test helpers for NativeMemoryChunk and NativeMemoryChunkPool; Added test utilities for time-based scheduling and native loading; Added tests for ImagePerfMonitor; Added unit tests for Ashmem-backed memory components; Added unit tests for BetterImageSpan sizing and margin support; Added unit tests for CombinedImageListenerImpl; Added unit tests for ContextChain; Added unit tests for DefaultDebugOverlayFactory2; Added unit tests for ForwardingControllerListener2 and ImagePerfState; Added unit tests for InfiniteSimpleAdapter and LocalResourceSimpleAdapter; Added unit tests for MediaUtils; Added unit tests for TimeWaster utility; Added unit tests for Vito core image handling components; Added unit tests for Vito core implementation components; Added unit tests for gesture detection samples; Added unit tests for native memory pool components; Added unit tests for simple memory types; Expanded test coverage for Drawee components; Removed broken StatFsHelper test suite; Removed tests for ObjectPool; Removed unit tests for TimeSpan class; Removed unused CoreRobolectricTestRunner test utility; Updated DataSource tests to use AssertJ and Robolectric v2; Updated FileUtilsTest assertions and license headers; Updated executor service tests to use Robolectric 4.1 and AssertJ; Updated test assertions and runner configuration in reference tests; Updated test suite for LimitedInputStream and TailAppendingInputStream.

Dependencies

Migrate Fresco build system to Gradle and publish to Maven Central

The Fresco library has migrated its build system from BUCK to Gradle, introducing a comprehensive set of new \build.gradle\ and \gradle.properties\ files for all core modules (such as \animated-base\, \imagepipeline\, \vito\, and \drawee-span\) and sample applications. This change establishes the project's new dependency management structure via \buildSrc\ and configures the artifacts for publication to Maven Central using the \com.vanniktech.maven.publish\ plugin, replacing the previous internal publishing workflow.

(dependencies) · high confidence

Migrate build system to AGP 8.5.2 and Gradle 8.7

The imagepipeline module has been updated to use Android Gradle Plugin 8.5.2 and Gradle 8.7. This upgrade modernizes the build configuration, ensuring compatibility with the latest Android development tools and potentially improving build performance and stability for developers integrating this library.

imagepipeline · high confidence

Upgrade Gradle wrapper to version 9.4.1

The Gradle wrapper has been updated to use Gradle 9.4.1 (previously 2.2.1). This upgrade includes configuration for network timeouts and distribution URL validation to improve build reliability and security.

gradle · high confidence

Upgrade libjpeg-turbo, libpng, and libwebp to latest versions

The static-webp module's native third-party libraries have been upgraded: libjpeg-turbo is updated to version 2.1.5.1, libpng to 1.6.37, and libwebp to 1.3.2. These updates bring performance improvements and bug fixes to JPEG, PNG, and WebP image processing within the static-webp component.

static-webp/src/main/jni/third-party · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 50 → 52 (+2.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 85 → 83 (-1.7)
  • Architecture 96 → 96 (-0.0)
  • Maturity 45 → 50 (+5.1)
  • Readiness 47 → 48 (+1.4)
  • Security 46 → 46 (+0.0)

Resolved (33)

  • ClassTooLong: AbstractAdaptiveCountingMemoryCache (imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache/AbstractAdaptiveCountingMemoryCache.java)
  • ClassTooLong: FrescoFlipperPlugin (tools/flipper-fresco-plugin/src/main/java/com/facebook/flipper/plugins/fresco/FrescoFlipperPlugin.java)
  • Dual entry points for image loading: VitoView exposes both show(ImageSource) and show(VitoImageRequest). While VitoImageRequest is a higher-level abstraction, exposing both on the same view class creates ambiguity about which should be used for standard use cases. It suggests a split in the API design between 'simple' and 'advanced' loading without clear separation of concerns.
  • Duplicated block (10 lines × 2) (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/BitmapPreparingImageFetchSubscriber.kt)
  • Duplicated block (11 lines × 2) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • Duplicated block (13 lines × 2) (samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito/renderer/RendererColorFilterExampleFragment.kt)
  • Duplicated block (13–21 lines × 3) (memory-types/ashmem/src/main/java/com/facebook/imagepipeline/memory/AshmemMemoryChunk.kt)
  • Duplicated block (14 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/listener/RequestLoggingListener.kt)
  • Duplicated block (14 lines × 3) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • Duplicated block (15 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/cache/BufferedDiskCache.kt)
  • Duplicated block (17 lines × 2) (vito/tools/liveeditor/src/main/java/com/facebook/fresco/vito/tools/liveeditor/LiveEditorUiUtils.kt)
  • Duplicated block (20–21 lines × 2) (samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito/renderer/RendererColorFilterExampleFragment.kt)
  • Duplicated block (4–5 lines × 3) (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/DebugDataProvider.kt)
  • Duplicated block (6 lines × 2) (vito/core-common-impl/src/main/java/com/facebook/fresco/vito/core/impl/debug/DebugOverlayDrawable.kt)
  • Duplicated block (7 lines × 2) (fbcore/src/main/java/com/facebook/common/util/HashCodeUtil.kt)
  • Duplicated block (7 lines × 2) (memory-types/ashmem/src/main/java/com/facebook/imagepipeline/memory/AshmemMemoryChunk.kt)
  • Duplicated block (7–8 lines × 3) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • FileTooLong: fresco/FrescoFlipperPlugin.java (tools/flipper-fresco-plugin/src/main/java/com/facebook/flipper/plugins/fresco/FrescoFlipperPlugin.java)
  • Hotspot: vito/core-java-impl/src/main/java/com/facebook/fresco/vito/core/impl/FrescoController2Impl.kt (vito/core-java-impl/src/main/java/com/facebook/fresco/vito/core/impl/FrescoController2Impl.kt)
  • Implementation class exposes same dual entry point inconsistency: VitoViewImpl2 (likely an internal implementation detail exposed in the public surface) repeats the ImageSource vs VitoImageRequest overload pattern found in VitoView, compounding the confusion.
  • …and 13 more

New (115)

  • Change coupling: KFrescoController.kt ↔ FrescoDrawable2Impl.kt (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/KFrescoController.kt)
  • Change coupling: KFrescoVitoDrawable.kt ↔ FrescoDrawable2Impl.kt (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/KFrescoVitoDrawable.kt)
  • ClassTooLong: AbstractAdaptiveCountingMemoryCache (imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache/AbstractAdaptiveCountingMemoryCache.kt)
  • Duplicated block (10 lines × 2) (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/BitmapPreparingImageFetchSubscriber.kt)
  • Duplicated block (11 lines × 2) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • Duplicated block (12 lines × 2) (samples/comparison/src/main/java/com/facebook/samples/comparison/DumpappInitializer.java)
  • Duplicated block (13 lines × 2) (drawee/src/main/java/com/facebook/drawee/drawable/MatrixDrawable.kt)
  • Duplicated block (13 lines × 2) (imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache/AbstractAdaptiveCountingMemoryCache.kt)
  • Duplicated block (13–21 lines × 3) (memory-types/ashmem/src/main/java/com/facebook/imagepipeline/memory/AshmemMemoryChunk.kt)
  • Duplicated block (14 lines × 3) (imagepipeline/src/main/java/com/facebook/imagepipeline/listener/RequestLoggingListener.kt)
  • Duplicated block (14 lines × 3) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • Duplicated block (15 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/cache/BufferedDiskCache.kt)
  • Duplicated block (16 lines × 2) (vito/core-java-impl/src/main/java/com/facebook/fresco/vito/core/impl/FrescoController2Impl.kt)
  • Duplicated block (17 lines × 2) (vito/tools/liveeditor/src/main/java/com/facebook/fresco/vito/tools/liveeditor/LiveEditorUiUtils.kt)
  • Duplicated block (32–33 lines × 2) (samples/showcase/src/main/java/com/facebook/fresco/samples/showcase/vito/renderer/RendererColorFilterExampleFragment.kt)
  • Duplicated block (4–5 lines × 3) (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/DebugDataProvider.kt)
  • Duplicated block (6 lines × 2) (vito/core-common-impl/src/main/java/com/facebook/fresco/vito/core/impl/debug/DebugOverlayDrawable.kt)
  • Duplicated block (7 lines × 2) (memory-types/ashmem/src/main/java/com/facebook/imagepipeline/memory/AshmemMemoryChunk.kt)
  • Duplicated block (7–8 lines × 3) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
  • Duplicated block (8–9 lines × 2) (fbcore/src/main/java/com/facebook/common/util/HashCodeUtil.kt)
  • …and 95 more

Changes since last survey

  • 41 commits — 39 feature/other, 2 fixes

By area

  • imagepipeline/src — 10 commits
  • imagepipeline-base/src — 5 commits
  • vito/core-java-impl — 5 commits
  • drawee/src — 4 commits
  • vito/core — 3 commits
  • .llms/rules — 2 commits
  • .claude/domain-expert — 1 commit
  • animated-base/src — 1 commit
  • animated-gif/src — 1 commit
  • fbcore/src — 1 commit
  • imagepipeline-base-test/src — 1 commit
  • middleware/src — 1 commit
  • samples/comparison — 1 commit
  • samples/scrollperf — 1 commit
  • samples/showcase — 1 commit
  • vito/core-impl — 1 commit
  • vito/litho-slideshow — 1 commit
  • vito/options — 1 commit

Notable commits

  • fix: Fix 294 of 5902 NoHungarianNotation violations by renaming private properties and local variables
  • fix: Fix Compose image tinting for Voice effects
  • change: //fbandroid/libraries/fresco/imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache:cache
  • change: Add ImageSourceProvider.smartForUri so Smart Fetch opt-ins keep empty sources
  • change: Add unit tests for options/EncodedImageOptions.kt
  • change: Allow a custom validation callback when building an ImageRequest
  • change: DiskStorageCacheTest: drop nullable Mockito type arguments
  • change: DownsampleUtilTest, LocalFileFetchProducerTest, QualifiedResourceFetchProducerTest: drop nullable Mockito type arguments
  • change: Drop nullable type arguments in BasePoolTest
  • change: Gate Vito on-fetch bitmap preparation with MobileConfig
  • change: GifImageDecoderTest: drop the nullable ImageDecodeOptions matcher type argument
  • change: Let ImageOptions turn off the JPEG resize transcode
  • change: Match BaseProducerContext.putExtra to the generic interface
  • change: Migrate rules/ACR_no_internal_imports_in_oss.md to the agentskills.io frontmatter format
  • change: Migrate rules/ACR_zero_dimension_guard.md to the agentskills.io frontmatter format
  • change: Move internal sample and Aloha startup to the common host
  • change: Move the fresco comparison sample's Glide app module to the Glide KSP processor
  • change: P3-175: facebook imagepipeline testing pins to True
  • change: Pin RoundedCornersDrawableTest to LEGACY graphics
  • change: Pin test classes that fail under NATIVE graphics to LEGACY
  • …and 21 more

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 7 added · 7 removed

Added bounded contexts (1)

  • fbcore/src/main/java

Removed bounded contexts (1)

  • fbcore/src/main/java

Added dependency edges (7)

  • animated-drawable → fbcore/src/main/java
  • animation2 → fbcore/src/main/java
  • comparison → fbcore/src/main/java
  • imagepipeline → fbcore/src/main/java
  • imagepipeline-base → fbcore/src/main/java
  • imagepipeline-volley → fbcore/src/main/java
  • showcase → fbcore/src/main/java

Removed dependency edges (was a dependency, now gone) (7)

  • animated-drawable → fbcore/src/main/java
  • animation2 → fbcore/src/main/java
  • comparison → fbcore/src/main/java
  • imagepipeline → fbcore/src/main/java
  • imagepipeline-base → fbcore/src/main/java
  • imagepipeline-volley → fbcore/src/main/java
  • showcase → fbcore/src/main/java

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

facebook/fresco was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit fd896040fed587532a8ebce85fc9478100be620d — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.63+preprod-4a8cc97a9484.