facebook/fresco

This system is an Android image loading and rendering library that manages the full lifecycle of image acquisition, decoding, caching, and display. It provides a modular architecture supporting various image formats including animated GIFs, WebP, and progressive JPEGs, with dedicated backends for network fetching and native memory management. The library also includes a modern rendering engine for efficient UI integration, comprehensive debugging tools, and utilities for embedding images within text layouts.

58 changes.

The project migrated its build system from BUCK to Gradle and published artifacts to Maven Central, while simultaneously upgrading the minimum SDK to API 21 and removing legacy backends like Volley and OkHttp 2. Core libraries underwent extensive refactoring, including a large-scale migration of Java code to Kotlin, adoption of null-safety annotations, and modernization of the Drawee pipeline with multi-listener support and viewport visibility handling.

54 changes.

The project focused on migrating the image rendering engine to the new Vito backend, introducing dedicated modules for animated GIF and WebP decoding with robust caching and sandboxing. This period also saw the expansion of the Showcase and ScrollPerf sample applications to demonstrate Vito capabilities, custom image format support, and performance tuning, alongside significant improvements to inline image handling and debugging tools.

61 changes.

This period focused on the development of the Vito image loading library, introducing a new Kotlin-based core, renderer, and Litho components alongside native memory and filter modules. The work involved migrating legacy Java code to Kotlin, establishing new native infrastructure for JPEG transcoding and image processing, and integrating debugging tools like Flipper and a live editor.

26 changes.

This period focused on expanding the Vito image rendering framework with Jetpack Compose support, native animated GIF capabilities, and comprehensive debug overlays for performance monitoring. Significant work also went into standardizing CI pipelines, adding extensive unit test coverage for core components, and introducing new APIs for image scaling, lifecycle management, and cache inspection.

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

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

The \flipper-fresco-plugin\ module has been added to the Fresco repository, introducing the \FrescoFlipperPlugin\ and \FrescoFlipperRequestListener\. This plugin enables developers to debug image loading by exposing Fresco's memory and disk caches through the Flipper interface, allowing them to list cached images and view their contents. It also tracks image request lifecycle events via the \DebugImageTracker\ to provide visibility into image loading performance and status within the Flipper UI.

flipper-fresco-plugin · high confidence

Users can now use the Volley library as a backend for the image pipeline's network fetcher. This change introduces the VolleyNetworkFetcher and RawRequest classes, which allow image requests to be executed via a provided Volley RequestQueue. Note that because Volley does not expose InputStreams, responses are buffered as complete byte arrays, which means progressive JPEG streaming is not supported with this backend.

imagepipeline-volley · high confidence

Introduces a new backend module that enables the image pipeline to use Volley for network fetching. This includes a new AndroidManifest and a configuration factory (VolleyImagePipelineConfigFactory) that allows users to build an ImagePipelineConfig backed by a Volley RequestQueue, with the addition of Nullsafe annotations to the backend classes.

imagepipeline-backends/imagepipeline-volley · high confidence

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

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

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

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

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

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

A new \FlipperCloseableReferenceLeakTracker\ class has been added to the \com.facebook.imagepipeline.debug\ package. This component enables the detection and reporting of memory leaks related to Fresco's \CloseableReference\ objects by forwarding leak events to a registered Flipper listener, allowing developers to identify and resolve resource management issues during debugging.

flipper · high confidence

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

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

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

The Showcase sample now includes a new Litho component that demonstrates how to decode and display nine-patch images using the Vito Litho integration. This example configures custom image decode options and a drawable factory to handle nine-patch scaling, providing a reference implementation for users integrating these features.

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

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

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

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

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

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

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

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

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

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

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

This change introduces a new static WebP decoder implementation within the webpsupport module. It adds WebPImageDecoder to handle decoding WebP images from byte buffers and input streams, integrating with the existing image pipeline via CloseableStaticBitmap. The implementation relies on WebpBitmapFactoryImpl, which provides hooks for decoding WebP data using the native static WebP library (loaded via StaticWebpNativeLoader) and includes error logging and sandboxing support. This enables direct decoding of static WebP images without relying on system-level WebP support.

static-webp/src/main/java/com/facebook/webpsupport · high confidence

A new StaticWebpNativeLoader class has been introduced to ensure the static-webp.so native library is loaded exactly once via SoLoader, providing a centralized initialization point for static WebP support within the image pipeline.

static-webp/src/main/java/com/facebook/imagepipeline · high confidence

The Zoomable sample now supports animated zoom transitions and easier integration of multiple gesture or controller listeners. A new AnimatedZoomableController provides smooth, interpolatable zoom animations using standard Android ValueAnimator, allowing developers to animate transform changes with a specified duration and completion callback. Additionally, MultiGestureListener and MultiZoomableControllerListener enable registering multiple child listeners for gesture events and controller state changes respectively, simplifying the composition of complex interaction behaviors in the sample app.

zoomable · high confidence

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

The DataSource abstraction in fbcore has been expanded with new capabilities and supporting classes. A new \RetainingDataSourceSupplier\ allows retaining previous results when swapping underlying data sources, which is useful for scenarios like GIF playback. The \DataSource\ interface now supports progress tracking via \getProgress()\ and \onProgressUpdate\, as well as carrying arbitrary metadata through \getExtras()\. A new \SimpleDataSource\ class (replacing the old \SettableDataSource\) and a singleton \SuccessfulVoidDataSource\ provide simpler ways to create settable and immediate data sources. Additionally, \DataSources.waitForFinalResult\ offers a blocking utility to wait for a final result with an optional timeout, and \BaseDataSubscriber\ now includes an \onProgressUpdate\ callback.

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

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

The drawee-pipeline module now supports multiple controller listeners via the new ControllerListener2 interface and provides a forwarding mechanism for image origin and performance data listeners (ForwardingImageOriginListener, ForwardingImagePerfDataListener). The DefaultDrawableFactory has been decoupled to accept custom animated and XML drawable factories, allowing applications to inject specialized rendering logic. Additionally, the PipelineDraweeControllerBuilderSupplier now integrates with DraweeConfig to enable custom drawable factories, debug overlay toggles, and default image performance data listeners, while also adding safety checks to prevent crashes from recycled bitmaps.

drawee-pipeline · high confidence

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

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

The Fresco plugin now includes a new FrescoFlipperDebugPrefHelper interface to manage debug overlay enablement status and listeners, alongside a comprehensive FlipperObjectHelper class that serializes Fresco image request properties, decode options, resize/rotation parameters, rounding settings, and image performance data into Flipper objects for inspection.

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

The ig-image-loader-sample module is introduced, providing a standalone Android application to demonstrate the IG Image Loader library. The app features a main activity with a navigation drawer that allows users to switch between different image view types (IGImageView, CircularImageView, and RoundedCornerImageView). It includes a custom HTTP downloader implementation for fetching images, a stubbed storage paths registry to satisfy dependency requirements without the full codegen pipeline, and a UI for configuring image loading options such as presets, image types, sample sizes, and fidelity settings.

ig-image-loader-sample · high confidence

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

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

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

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

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

A new NativeMemory module has been added to the codebase, introducing the NativeMemoryChunk class to wrap native memory chunks via JNI and the NativeMemoryChunkPool class to manage a pool of these chunks. NativeMemoryChunk handles native memory allocation, reading, writing, and copying with thread-safe locking, while NativeMemoryChunkPool extends the existing MemoryChunkPool to instantiate NativeMemoryChunk objects. The module uses the Nullsafe LOCAL mode and loads the imagepipeline library via NativeLoader.

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

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

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

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 · high confidence

Added the VitoSpanLoader and VitoSpan classes in the textspan module, enabling the integration of Vito-based image spans within RichText. This change allows images to be loaded and displayed as inline spans in text views, with lifecycle management handled via attach/detach listeners to ensure resources are properly fetched and released.

textspan · high confidence

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

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

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

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

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

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

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

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

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

New Kotlin source files have been added to the imagepipeline-native module, introducing the Bitmaps utility object for native bitmap copying, the DalvikPurgeableDecoder abstract class for handling bitmap decoding on older Android versions, and the ImagePipelineNativeLoader for managing the loading of the libimagepipeline.so native library.

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

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

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

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

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

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

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

The Fresco Vito source module introduces several new ImageSource types to support diverse image loading scenarios: BitmapImageSource, ColorImageSource, DrawableImageSource, and DrawableResImageSource (which includes configurable prefetching logic), as well as EmptyImageSource with an isExpectedEmpty flag to distinguish expected empty states from failures. Additionally, FirstAvailableImageSource allows fallback chains, IncreasingQualityImageSource supports progressive quality loading with media extras, and SmartImageSource now exposes a smartFetchOptIn property for product-level Smart Fetch control. These changes expand the API surface for developers to handle specific image data types and loading behaviors within the Vito architecture.

source · high confidence

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

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

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

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

A new \vito/drawee-support\ module has been added to bridge Fresco's legacy Drawee API with the new Vito image pipeline. This includes \VitoViewInflater\ to parse Drawee XML attributes (such as scale types, placeholders, and rounding) into Vito \ImageOptions\, \RoundingParamsWrapper\ to convert rounding and border settings, and \DrawableFactoryWrapper\ to adapt drawable factories. A deprecated \ControllerListenerWrapper\ is also provided to map legacy controller events to Vito listeners, enabling a smoother migration path for existing Drawee-based code.

vito/drawee-support · high confidence

The vito/textspan module introduces VitoSpan, a new ReplacementSpan implementation that enables image rendering within RichText components using the Vito image pipeline. This component wraps the existing BetterImageSpan logic to integrate with FrescoDrawableInterface, allowing text layouts to include inline images fetched via the Vito system.

vito/textspan · high confidence

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

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

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

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

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

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

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

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

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

Developers can now use a new lightweight debug overlay (LightweightDebugOverlayFactory2) that displays a color-coded bar indicating image origin (memory, disk, network) and configurable debug text such as dimensions, format, and URI. Additionally, a new DataSourceImageSource class allows direct supply of a DataSource for image loading, simplifying integration with existing data sources.

core-java-impl · high confidence

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

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

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

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

The imagepipeline-test module now includes new helper classes to support testing: IntPair and PoolStats provide utilities for tracking and inspecting memory pool statistics, while MockBitmapFactory offers a Kotlin-based helper to create mocked Bitmap objects with configurable dimensions and configurations for unit tests.

imagepipeline-test · high confidence

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

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

The animation2 sample app now includes a media control example that allows users to play, pause, reset, and scrub through animations using a seek bar and toggle button. It also demonstrates the new frame preparation capabilities by introducing a configurable bitmap animation backend that pre-codes a fixed number of frames using a dedicated executor, improving performance for complex animations.

animation2 · high confidence

The Instagram image loader sample app has been updated to allow engineers to switch between different image loading and rendering paths via seven configuration toggles. Users can now enable or disable Vito rendering, route requests through Fresco's ImagePipeline or the legacy IG pipeline, and choose between Fresco's memory/disk caches and IG's native implementations. The app also includes a debug overlay to visualize pipeline paths, load timing, and cache details, along with preset configurations for common UI patterns like feed photos, avatars, and story previews.

repository · high confidence

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

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

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

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

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

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

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

The Showcase sample app has been refactored to use a new list-based navigation entry point (ShowcaseListActivity) and a modular data model (ExampleCategory, ExampleItem) for organizing samples. This update significantly expands the ImageOptions configurator in the Vito sample, adding interactive controls for image sources (including increasing quality, first available, and local icons), image formats, rounding, borders, scale types, color filters, fading, placeholders, errors, progress indicators, and overlays. It also introduces new sample fragments for region decoding (ImagePipeline and Vito), nine-patch image handling, and post-processing (including benchmark helpers and a scaling blur filter), along with debug utilities like a LogcatRequestListener and DebugImageListener to aid in development and troubleshooting.

showcase · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The comparison sample app has replaced its legacy ListView-based adapters with new RecyclerView adapters for Picasso, Universal ImageLoader, and Volley. This change improves list performance and aligns the sample with modern Android development standards by adopting AndroidX components, including the use of androidx.collection.LruCache for Volley's memory caching implementation.

comparison · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The DeferredReleaser now uses a concurrent implementation that safely handles resource release from background threads, preventing race conditions and crashes when called off the UI thread. The DraweeEventTracker can now be disabled via a new disable() method to reduce overhead, and additional internal events are tracked for better debugging. Additionally, the RetryManager exposes a new setMaxTapToRetryAttempts() method, allowing developers to customize the number of tap-to-retry attempts.

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

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

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

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

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

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

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

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

The image options classes (AnimatedOptions, BorderOptions, DecodedImageOptions, RoundingOptions) have been migrated from Java to Kotlin. This migration includes manual implementations of equals and hashCode for data classes to ensure correct behavior. New capabilities include controlling animated image playback via loop counts and the ability to disable animations entirely to show static images. Additionally, RoundingOptions now supports anti-aliasing for circular images, and DecodedImageOptions exposes new options for intermediate bitmap transformations and loading thumbnails only.

options · high confidence

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

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

The native C/C++ 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 JNI bindings for bitmap operations (pinning, copying) and native memory management (allocation, copying, byte access), along with their associated build scripts (Android.mk, Application.mk) and exception handling utilities. Copyright headers have been updated from Facebook to Meta, and the license has been standardized to MIT.

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

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

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

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

The internal image performance tracking logic has been restructured: the previous listener implementation is replaced by a new ImagePerfStateManager class that centralizes state updates for image load events (submit, intermediate/final image set, failure, release) and visibility changes. This change also introduces the ImagePerfLoggingListener interface and simplifies the visibility method naming in the notifier, affecting how performance metrics and visibility states are recorded and reported for image loading operations.

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

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

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

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

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

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

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

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

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

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

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

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

The Vito core configuration has been migrated to Kotlin, introducing \DefaultFrescoVitoConfig\ which sets the default behavior for image loading lifecycle events. This change establishes specific defaults for release strategies (e.g., \DELAYED\ on unbind, \NEXT\_FRAME\ on unmount/detach), prefetch data source closure timing, and dynamic size experiments. It also introduces boolean flags to control features such as handling image results on a background thread, using intermediate images as placeholders, and fixing listener retriggering bugs during bind operations, allowing users to opt into these behaviors via configuration.

core · high confidence

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

The WebP support detection logic (WebpSupportStatus) and the WebP bitmap factory interface (WebpBitmapFactory) have been moved into the fbcore module. This change centralizes the core WebP capability checks and factory definitions, making them available as part of the common core library rather than being scattered or dependent on the image pipeline implementation directly. The WebpSupportStatus class now handles checking for simple and extended WebP support via header inspection, while WebpBitmapFactory provides the interface for decoding WebP images with optional error logging and bitmap creation hooks.

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

Added Android instrumentation tests for WebP decoding; Added E2E test for the Fresco Showcase app launch; 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 implementation components; Added unit tests for gesture detection samples; Added unit tests for image layer handling and drawable recycling; 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.

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

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

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

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 25 → 47 (+21.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 37 → 89 (+51.8)
• Architecture 96 → 99 (+2.7)
• Maturity 57 → 55 (-1.7)
• Readiness 13 → 50 (+37.2)
• Security 20 → 63 (+42.9)
• Accessibility 33 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (16 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/cache/BufferedDiskCache.kt)
• Duplicated block (16 lines × 2) (vito/tools/liveeditor/src/main/java/com/facebook/fresco/vito/tools/liveeditor/LiveEditorUiUtils.kt)
• Duplicated block (18 lines × 2) (fbcore/src/main/java/com/facebook/common/util/HashCodeUtil.kt)
• Duplicated block (22 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/listener/RequestLoggingListener.kt)
• Duplicated block (24 lines × 2) (imagepipeline/src/main/java/com/facebook/imagepipeline/listener/RequestLoggingListener.kt)
• Duplicated block (7 lines × 2) (vito/core-common-impl/src/main/java/com/facebook/fresco/vito/core/impl/debug/DebugOverlayDrawable.kt)
• Duplicated block (7 lines × 2) (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/DebugDataProvider.kt)
• Duplicated block (7 lines × 2) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
• Duplicated block (7 lines × 2) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
• Duplicated block (8 lines × 2) (vito/options/src/main/java/com/facebook/fresco/vito/options/ImageOptions.kt)
• FileTooLong: assets/doclava-developer-docs.js (docs/javadoc/assets/doclava-developer-docs.js)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 56 more

• 1.getResult (cognitive 27) (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/LocalThumbnailBitmapSdk29Producer.java)
• 1.onNewResultImpl (cognitive 17) (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/BitmapMemoryCacheProducer.java)
• 1.then (cognitive 18) (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/DiskCacheReadProducer.java)
• AbstractDraweeController.onFailureInternal (cognitive 16) (drawee/src/main/java/com/facebook/drawee/controller/AbstractDraweeController.java)
• AnimatedDrawable2.draw (cognitive 19) (animated-drawable/src/main/java/com/facebook/fresco/animation/drawable/AnimatedDrawable2.kt)
• AnimatedImageCompositor.prepareCanvasWithClosestCachedFrame (cognitive 16) (animated-base/src/main/java/com/facebook/imagepipeline/animated/impl/AnimatedImageCompositor.java)
• BitmapMemoryCacheProducer.produceResults (cognitive 17) (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/BitmapMemoryCacheProducer.java)
• Boundary-crossing change coupling: AnimationLoaderFactory.kt ↔ AnimatedFactoryProvider.kt (animated-drawable/src/main/java/com/facebook/fresco/animation/bitmap/preparation/ondemandanimation/AnimationLoaderFactory.kt)
• Boundary-crossing change coupling: NopUriModifier.kt ↔ VitoImagePipeline.kt (urimod/src/main/java/com/facebook/fresco/urimod/NopUriModifier.kt)
• Boundary-crossing change coupling: NopUriModifier.kt ↔ VitoImagePipelineImpl.kt (urimod/src/main/java/com/facebook/fresco/urimod/NopUriModifier.kt)
• Boundary-crossing change coupling: ResizeAndRotateProducer.java ↔ NativeJpegTranscoder.java (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/ResizeAndRotateProducer.java)
• Change coupling: CombinedImageListenerImpl.kt ↔ KFrescoController.kt (vito/core-common-impl/src/main/java/com/facebook/fresco/vito/core/impl/CombinedImageListenerImpl.kt)
• Change coupling: DebugDataProvider.kt ↔ DebugOverlayHandler.kt (vito/core-impl/src/main/java/com/facebook/fresco/vito/core/impl/DebugDataProvider.kt)
• ClassTooLong: AbstractAdaptiveCountingMemoryCache (imagepipeline-base/src/main/java/com/facebook/imagepipeline/cache/AbstractAdaptiveCountingMemoryCache.java)
• ClassTooLong: AbstractDraweeController (drawee/src/main/java/com/facebook/drawee/controller/AbstractDraweeController.java)
• ClassTooLong: DecodeProducer (imagepipeline/src/main/java/com/facebook/imagepipeline/producers/DecodeProducer.kt)
• ClassTooLong: DiskStorageCache (imagepipeline-base/src/main/java/com/facebook/cache/disk/DiskStorageCache.kt)
• ClassTooLong: FrescoController2Impl (vito/core-java-impl/src/main/java/com/facebook/fresco/vito/core/impl/FrescoController2Impl.kt)
• ClassTooLong: FrescoFlipperPlugin (tools/flipper-fresco-plugin/src/main/java/com/facebook/flipper/plugins/fresco/FrescoFlipperPlugin.java)
• ClassTooLong: ImagePipeline (imagepipeline/src/main/java/com/facebook/imagepipeline/core/ImagePipeline.kt)
• …and 327 more

• 82 commits — 76 feature/other, 6 fixes

• imagepipeline/src — 23 commits
• samples/showcase — 9 commits
• vito/core — 5 commits
• drawee/src — 4 commits
• imagepipeline-base/src — 4 commits
• vito/core-impl — 4 commits
• vito/core-java-impl — 4 commits
• (root) — 3 commits
• .llms/rules — 3 commits
• animated-drawable/src — 2 commits
• buildSrc/src — 2 commits
• fbcore/src — 2 commits
• ig-image-loader-sample/src — 2 commits
• .github/workflows — 1 commit
• animated-base/src — 1 commit
• animated-gif/src — 1 commit
• ci/build-and-test.sh — 1 commit
• imagepipeline-backends/imagepipeline-okhttp3 — 1 commit
• memory-types/ashmem — 1 commit
• native-imagetranscoder/build.gradle — 1 commit

• fix: Fix Fresco release workflow SDK setup
• fix: Fix NullPointerException in ImageTracker.removeDrawable due to concurrent access
• fix: Fix OSS Gradle Kotlin compatibility
• fix: Fix OSS build
• fix: Fix android_crash:java.lang.NullPointerException:com.facebook.imagepipeline.listener.ForwardingRequestListener2.requiresExtraMap
• fix: Fix in webp_bitmapfactory.cpp — T276360994
• change: //fbandroid/libraries/fresco/memory-types/ashmem/src/main/java/com/facebook/imagepipeline/memory:memory
• change: //fbandroid/libraries/fresco/native-imagetranscoder/src/main/java/com/facebook/imagepipeline/nativecode:nativecode
• change: Add PrefetchData and prefetch telemetry plumbing (OSS)
• change: Add evictFromMemoryCache(ImageRequest) so custom cache keys can be evicted
• change: Add scheduleLastResultImmediately image pipeline experiment
• change: Add shared encoded memory cache boundary
• change: Add streaming image decoder support
• change: Add translation description for Vito View prefetch title string
• change: Add translator context to Fresco Showcase color XML help string
• change: Add translator context to Fresco Showcase image orientation strings
• change: Add translator description for Create Transformed showcase string
• change: Add translator description for Vito View KTX showcase string
• change: Add translator description to Fresco Showcase app_name
• change: Add unit tests for core/VitoImageRequestListener.kt
• …and 62 more

• Containers 0 added · 0 removed · contexts 31 added · 0 removed · edges 92 added · 0 removed

• animated-base
• animated-drawable
• animated-gif-lite
• animation2
• comparison
• core
• core-common-impl
• core-java-impl
• drawee
• drawee-pipeline
• drawee-span
• fbcore
• flipper
• flipper-fresco-plugin
• imagepipeline
• imagepipeline-base
• imagepipeline-base-test
• imagepipeline-volley
• liveeditor
• nativecode
• …and 11 more

• animated-base → animated-drawable (coupling)
• animated-base → core
• animated-base → fbcore
• animated-base → imagepipeline-base
• animated-base → options
• animated-drawable → core
• animated-drawable → drawee
• animated-drawable → fbcore
• animated-drawable → imagepipeline-base
• animated-drawable → options (coupling)
• animated-gif-lite → animated-base
• animated-gif-lite → imagepipeline-base
• animation2 → animated-base
• animation2 → animated-drawable
• animation2 → fbcore
• comparison → fbcore
• comparison → imagepipeline-base
• core → drawee
• core → options (coupling)
• core → source
• …and 72 more

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

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.