BaseRecyclerViewAdapterHelper is a powerful and flexible RecyclerView adapter library for Android. It simplifies RecyclerView implementation by providing enhanced adapters with features like multiple view types, load more functionality, drag and swipe capabilities, item animations, header/footer support, and DiffUtil integration. The library is architecturally sound with a clean separation of concerns, offering BaseQuickAdapter as its foundation along with specialized adapters for different use cases. It's actively maintained with up-to-date dependencies and demonstrates strong Android engineering practices.
This repository is the core Android implementation of the Lottie animation library, designed to render vector-based animations (exported from Adobe After Effects as JSON) natively on Android devices. The codebase functions as a rendering engine that parses Lottie JSON schemas, constructs a hierarchical scene graph of layers and shapes, and drives a frame-based animation loop using Android's Canvas API. It supports two primary integration points: a traditional View-based API (LottieAnimationView) for XML layouts and a Jetpack Compose API (LottieAnimation) for modern declarative UIs. The system handles complex rendering features including masks, mattes, gradients, text, and dynamic property overrides at runtime. Architecturally, the project is a multi-module Gradle build consisting of a core library (lottie), a Compose integration module (lottie-compose), and extensive testing/sampling infrastructure. The core logic relies on a custom JSON parser (JsonReader) to deserialize animation data into model objects (LottieComposition), which are then rendered by LottieDrawable or LottiePainter. The architecture emphasizes performance through offscreen rendering strategies (OffscreenLayer) and memory management via bitmap pooling. It also implements a robust caching system (LottieCompositionCache) and async loading mechanisms (LottieCompositionFactory) to handle network and asset sources efficiently. The codebase demonstrates high craftsmanship in its rendering engine, particularly in handling edge cases like 3D rotations, blend modes, and text rendering across different Android API levels. It maintains parity between View and Compose implementations, ensuring consistent behavior across UI paradigms. The testing strategy is rigorous, utilizing snapshot testing (snapshot-tests) to verify visual fidelity across various hardware configurations and API levels, preventing visual regressions in the complex rendering logic.
Glide is a fast and efficient open source media management and image loading framework for Android. It handles fetching, decoding, and displaying images from various sources (network, local storage, resources, content URIs) with sophisticated memory and disk caching. The architecture features a modular design with core library, sample applications, integration modules for different networking stacks (OkHttp, Volley, Cronet), and annotation processing for code generation. Key components include a plug-in architecture for customizable loaders/decoders, bitmap pooling to reduce GC pressure, multi-level caching (memory/disk), and transformation system for image manipulation. Entry points are Glide.get() and Glide.with() for creating request managers, with generated type-safe APIs via annotation processing.
Chucker is a production-grade Android library for inspecting HTTP(S) traffic in-app. It acts as an OkHttp interceptor, capturing full request/response details (headers, bodies, timing, errors) and persisting them to a local Room database. The library provides a built-in Material Design UI for browsing, searching, filtering, and exporting transactions (HAR 1.2, plain text, curl commands). It is designed as a debug-only tool via a no-op variant for release builds. The architecture follows a clean separation: public API (ChuckerInterceptor, ChuckerCollector, BodyDecoder), internal data layer (Room entities, DAO, repository), support utilities (okio stream manipulation, JSON formatting, background services), and a full set of UI fragments/adapters. The codebase is well-tested (unit tests for interceptors, DAO, repository, utilities, ViewModels) and follows modern Android development practices (Kotlin, Coroutines, LiveData/Flow, ViewBinding, Compose sample). It handles edge cases like compressed bodies, large payloads, binary formats (protobuf), GraphQL, and SSL/TLS information. The project also includes CI/CD pipelines, automated dependency updates via Renovate, and migration guides for previous versions. While primarily an application library, it has a strong data storage component (Room database) and export functionality (HAR generation), making it useful for debugging network issues in any Android app.
Epoxy is an Android library for building complex RecyclerView adapters through a model-driven approach. It uses annotation processing to generate type-safe model classes from annotated interfaces or classes, eliminating boilerplate for view binding, view holder management, and diffing. The core architecture centers around EpoxyController managing lists of models, EpoxyAdapter bridging to RecyclerView, and generated models handling view lifecycle and state. Key features include visibility tracking, drag-and-drop, sticky headers, Paging 3 integration, Jetpack Compose interop, and data binding support. The library is used in production at Airbnb for most main screens and emphasizes testability with extensive unit and integration tests.
Matisse is an Android image and video selection library built entirely with Kotlin and Jetpack Compose. It provides two primary entry points: `MatisseContract` for a full-featured media picker (grid selection, bucket filtering, preview, multi-select with configurable constraints) and `MatisseCaptureContract` for a standalone camera capture flow. The library abstracts image loading via an `ImageEngine` interface with built-in Coil and Glide implementations, and handles MediaStore permissions across Android versions including granular media permissions and partial access on Android 14+. Capture strategies are modular (FileProvider, MediaStore, Smart), allowing hosts to control storage location and permission needs. The sample app demonstrates configuration options (grid columns, max selectable, fast select, theme). The codebase is well-structured, uses clean architecture with ViewModels and Paging 3, and relies on AndroidX and Jetpack Compose. It is primarily a reusable library with high craftsmanship.
Camposer is a Kotlin Multiplatform camera library that provides a unified Compose Multiplatform API for camera functionality on Android (via CameraX) and iOS (via AVFoundation). It offers camera preview, photo capture, video recording, flash/torch control, zoom, tap-to-focus, exposure compensation, mirror mode, multi-lens selection, video stabilization, and image analysis (including barcode/QR scanning via the optional code-scanner module). The library is published on Maven Central and includes sample apps demonstrating both Android-only and cross-platform usage. The architecture follows a clean separation of concerns with an internal engine/applier layer: `CameraState` holds reactive state flows for all configurable properties, and platform-specific appliers (`PreviewApplier`, `VideoApplier`, etc.) write changes to the underlying hardware when the state changes. The public API exposes `CameraPreview` composable, `CameraSession` for state/info access, and `CameraController` for capture commands. The codebase is well-structured with expect/actual pattern, version catalogs, ABI validation, and extensive test infrastructure (unit tests, device tests, iOS tests). It is a well-crafted, actively maintained library with high reusability potential.
This repository is a robust Android library designed for debugging applications by providing a user-friendly interface to view system logs (logcat). It functions as a standalone framework that integrates into an Android app via Gradle dependency. The core functionality involves capturing logs from the system logcat process, parsing them using regex patterns, filtering them based on user-defined rules (TAG, level, search keywords), and displaying them in a RecyclerView with features like auto-merging, highlighting, and saving to file. The architecture relies on a ContentProvider for automatic initialization, a Foreground Service to maintain the log capture process (handling Android 8+ and 14+ restrictions), and a Floating Window/Notification for user interaction. The code demonstrates strong engineering practices, particularly in handling Android version fragmentation (e.g., specific handling for Android 12's Foreground Service restrictions and Android 14's targetSdk 34 requirements). It includes OOM protection mechanisms by limiting the number of displayed logs and uses MD5 hashing to prevent duplicate log entries when restarting the capture stream.
This repository contains an Android library for creating additive animations, where multiple animations can be combined by adding their values together rather than having later animations override earlier ones. The library provides a fluent API for animating View properties (position, size, rotation, alpha, etc.) and custom object properties. Key features include physics-based spring animations with configurable stiffness and damping, animation chaining with flexible timing controls, view visibility animations that automatically handle state transitions, and a sophisticated animation state system that determines whether to run animation start/end logic based on the current state of the target object. The implementation stands out for its physics-based spring solver (SpringSolver.kt) which provides an analytical solution to the damped harmonic oscillator equations, handling all damping regimes correctly. The RunningAnimationsManager provides intelligent state management for animations, eliminating common boilerplate for visibility and state-based animations. The library is actively maintained with recent updates, uses current AndroidX dependencies, and follows modern Android development practices with Kotlin coroutines and Java 17 compatibility.
Square Logcat is a lightweight Kotlin multiplatform logging library that provides a simple API for logging on Android and JVM platforms. The library wraps Android's android.util.Log class and offers a similar API for JVM environments. Key architectural decisions include inlined logging functions that avoid string evaluation when logging is disabled, automatic tag extraction from calling class names without stacktrace overhead, and support for multiple concurrent loggers with thread-safe management. The library uses kotlinx.atomicfu for thread-safe collections and follows a clean separation between the logging API (logcat function) and logger installation (LogcatLogger interface).
FirebaseUI-Android is an open-source library providing pre-built UI components for Firebase Authentication, Realtime Database, Cloud Firestore, and Cloud Storage. It is a multi-module Android library published on Maven Central. The primary module, `firebase-ui-auth`, has been rewritten in Jetpack Compose with Material 3, offering a high-level composable (`FirebaseAuthScreen`) and a Kotlin DSL for configuration. It supports 12+ identity providers (Google, Facebook, Email, Phone, Apple, etc.), multi-factor authentication (SMS/TOTP), credential linking, anonymous upgrade, and email link sign-in. The `firebase-ui-database` and `firebase-ui-firestore` modules provide RecyclerView adapters with paging support (AndroidX Paging 3) for displaying Firebase data. The `firebase-ui-storage` module integrates with Glide for loading images from Firebase Storage. A demo app and end-to-end tests against the Firebase Auth Emulator are included. Architecturally, the library is split into separate Gradle modules: `auth`, `database`, `firestore`, `storage`, `common`, and `lint`. The auth module uses Kotlin coroutines, StateFlow, and a sealed class state machine (`AuthState`) to manage authentication flows. The database/firestore modules are older Java-based implementations using lifecycle-aware adapters and observable arrays. The library maintains a version catalog (libs.versions.toml) with modern dependencies (Kotlin 2.4.10, AGP 9.3.0, Compose BOM 2026.06.01). Key entry points include `FirebaseAuthScreen` (Compose), `FirebaseAuthUI` (singleton for sign-out/delete/auth state), `AuthFlowController` (Activity-based alternative), `FirebaseRecyclerAdapter`/`FirestoreRecyclerAdapter`, and `FirebaseImageLoader` (Glide integration). The primary data flows involve Firebase SDKs for authentication, database listeners, and image loading. The library is designed to be embedded in host Android apps, handling complex auth flows with minimal developer effort. The codebase demonstrates strong craftsmanship in the auth module’s state machine and Compose UI, but shows signs of technical drift due to mixed UI generations (legacy XML layouts alongside new Compose), some deprecated API usage (e.g., `fetchSignInMethodsForEmail`, `startActivityForResult`), and incomplete localizations. The database/firestore modules are mature but use older patterns. Overall, the library is well-structured and actively maintained, with a beta version (10.0.0-beta04) indicating ongoing development.
This repository is a GitHub template for bootstrapping Kotlin Android projects with a modern, opinionated build setup. It provides a multi-module structure (app, library-android, library-kotlin, library-compose) with pre-configured static analysis via detekt, CI/CD via GitHub Actions, and publishing to Maven Central. The codebase demonstrates best practices for Gradle Kotlin DSL, version catalogs, and precompiled script plugins. The sample modules include a simple factorial calculator to illustrate cross-module dependencies and testing patterns (unit, instrumentation, and Compose UI tests). While the template is not a production application itself, it serves as a solid foundation for new Android projects, emphasizing code quality and automation from the start.
AppUpdater is a multi-module Android library that provides in-app update functionality: it checks a remote version, downloads the APK, shows progress via notification or dialog, and installs the APK across Android versions. The core `app-updater` module contains the update orchestration, download/install services, notification handling, and file/checksum utilities; the `app-dialog` module provides a ready-made update dialog; the `app` module is a sample. The main entry point is the `AppUpdater` builder/facade, which accepts an `UpdateConfig` and optional custom parser/strategy implementations, so consumers can plug in their own update-info JSON schema.
This repository contains FlipView, an Android library that extends ViewFlipper to provide animated view flipping capabilities similar to Gmail's swipe actions. The core component is a custom ViewGroup that manages front and rear views with configurable animations, layouts, and images. It supports auto-flipping at intervals, user-triggered flips, initial cascade animations for multiple views, and SVG image support. The library includes sophisticated animation coordination to avoid visual glitches and provides extensive customization through XML attributes. A sample application demonstrates usage in various configurations including RecyclerView integration.
PhotoEditor is an Android library (published on Maven Central) that provides a comprehensive image editing SDK. It allows users to draw on images with customizable brushes and shapes (line, oval, rectangle, arrow), apply filter effects via Android's deprecated MediaEffect API, add and edit text with rich styling (color, font, shadow, border), insert emoji and stickers, and perform pinch-to-scale/rotate gestures on added elements. The library is built around a `PhotoEditorView` custom RelativeLayout that composes an ImageView, a DrawingView (custom canvas for brush/shape rendering), and an ImageFilterView (GLSurfaceView for filters). The architecture employs several design patterns: Builder (PhotoEditor, ShapeBuilder, TextStyleBuilder, SaveSettings), Composite (Graphic interface with Text, Sticker, Emoji implementations), Strategy (Shape interface with concrete shapes), and Listener (OnPhotoEditorListener, BrushViewChangeListener). The sample app demonstrates all features. The library has a robust undo/redo system managed by GraphicManager and PhotoEditorViewState. While the core functionality is solid, the filter implementation relies on deprecated Android APIs (android.media.effect), which is a known limitation and source of issues. The codebase is well-structured with unit and instrumentation tests, CI/CD pipelines, and proper Kotlin coroutines for async saving.
This repository is a Kotlin/Java library providing Certificate Transparency (CT) verification for Android and JVM applications. It prevents man-in-the-middle attacks by validating TLS certificates against public CT logs. The library offers multiple integration approaches: Java Security Provider, OkHttp interceptors, TrustManager and HostnameVerifier wrappers for HttpURLConnection/Volley/WebView, and direct API usage. Key features include CT log list fetching and parsing, SCT verification, optional CRL-based certificate revocation checking, and configurable caching. The architecture is modular with a core library, Android-specific extensions, and a sample application demonstrating all integration methods. The code employs modern Kotlin idioms (coroutines, sealed classes, builder patterns) and maintains strong separation of concerns between network fetching, policy enforcement, chain cleaning, and verification logic.
This repository is an Android library for GPU-accelerated real-time image and video processing, named 'android-gpuimage-plus' (CGE engine). It provides a comprehensive set of OpenGL ES shader-based filters (brightness, contrast, hue, saturation, vignette, sketch, liquify, color mapping, LUT, etc.) and a filter chain pipeline for applying multiple effects. The library supports camera preview with live filters, video playback with effects, and video recording to MP4 using an optional FFmpeg backend. It includes a demo application (cgeDemo) showcasing all features, including image editing, camera capture, video player, and face tracking (stub). The architecture is a Java/Kotlin API layer with JNI wrappers to a native C++ core that manages OpenGL ES contexts, shader programs, and frame buffer objects. External dependencies include OpenGL ES 2.0/3.0, optional FFmpeg (version 3.4.8), and Android Camera1/CameraX APIs. The library is published as an AAR artifact with variants for different page sizes (4KB and 16KB) and optional video module.
Trinea Android Common is a mature Android library providing a comprehensive set of caching components (in-memory, disk, HTTP), custom UI widgets (pull-to-refresh ListView, horizontal ListView, border ScrollView, single-page Gallery), and a wide array of utility classes for common Android development tasks. The cache system is particularly well-architected, featuring a pluggable eviction policy interface with 13+ strategies, two-level caching (memory + SD card), and preloading support. The library is written in Java and targets API 21+, with AndroidX dependencies. While the codebase is functional and well-documented, it shows its age with patterns like AsyncTask and raw HttpURLConnection, and lacks Kotlin or modern coroutine support. It remains a solid reference for cache implementation patterns and utility functions, but for new projects, developers may prefer more modern alternatives like Coil or Glide for image loading.
Yasea is an Android live-streaming library and demo application that captures camera video and microphone audio, applies real-time GPU image filters, hardware-encodes to H.264/AAC via MediaCodec, muxes into FLV, and publishes over RTMP to servers such as SRS. The main entry point is SrsPublisher, which orchestrates SrsCameraView (an OpenGL ES preview surface), SrsEncoder (MediaCodec lifecycle and format negotiation), SrsFlvMuxer (FLV-over-RTMP publishing), and SrsMp4Muxer (simultaneous MP4 recording). The demo app (MainActivity) provides a working UI for URL entry, publish/pause, camera switching, recording, and filter selection. Architecturally, the repo is a Gradle project with two modules: a reusable Android library (library/) and a demo app (app/). The library is a monolith that bundles large vendored third-party codebases as source: Google's libyuv (native YUV/RGB conversion and scaling), mp4parser (ISO BMFF/MP4 parsing and authoring), simple-rtmp (RTMP client protocol), and MagicCamera (40+ GPU image filters with GLSL shaders). The repo's own code is the net.ossrs.yasea package, which integrates these pieces: camera frames flow through the GLSurfaceView filter chain as RGBA, are converted to I420/NV12 by the libenc JNI bridge (libenc.cc wrapping libyuv), encoded by MediaCodec, and muxed to FLV/MP4. Audio is captured via AudioRecord and encoded to AAC. Despite a recent commit, the codebase is frozen in the 2017-2020 Android era: compileSdk/targetSdk 26, Android support library 26.1.0, the deprecated Camera API, Gradle 6.5 with AGP 4.1.1, and a mips ABI that modern NDKs no longer support. The native build is commented out in library/build.gradle, and 285 open issues remain. Technical drift is high. This is purely an application/library repo - no data pipelines, notebooks, or research components.
This is the Anko library for Android, a Kotlin DSL that provides type-safe builders for UI layouts, SQLite queries, intents, dialogs, async tasks, logging, and other common Android patterns. The repository additionally contains a code generator (using ASM to parse Android SDK classes) that produces extension functions for views, properties, listeners, and services per API level, and an IntelliJ/Android Studio plugin that includes XML-to-Anko conversion, live preview of DSL layouts, and refactoring intentions. The library is officially deprecated (see GOODBYE.md) in favor of Jetpack Compose, Splitties, and Android KTX; the last commit was in 2019. The codebase is well-structured overall, but the generated files are massive and repetitive, and the library has not kept pace with the Android ecosystem (e.g., still uses android.support libraries, GlobalScope for coroutines, and targets SDK versions up to 28). Reusable components include the static commons (Logging, Async, Intents, AlertBuilder), the code generator's class tree and rendering pipeline, and the SQLite query builders.