LeakCanary is a sophisticated memory leak detection library for Android and Java, developed by Square. In production, it integrates into Android applications to automatically monitor object allocations, trigger heap dumps upon detecting suspicious memory growth, and analyze these dumps to identify leaking objects. It provides detailed leak traces showing the reference path from GC roots to the leaking object, helping developers pinpoint the root cause. The project also includes Shark Dive, a powerful desktop application for interactive heap dump exploration using treemap, radial, and stack visualizations, and a CLI tool for batch analysis. The architecture is a multi-module monorepo with a clean separation of concerns. The core analysis engine (shark) is platform-independent, handling HPROF parsing, heap graph construction, dominator tree computation (Lengauer-Tarjan), and shortest path finding. Android-specific modules (leakcanary-android-*) provide lifecycle integration, UI, and notification handling. The desktop app (shark-dive-app) is built with Kotlin Compose UI and features an agent protocol for AI-assisted analysis. The codebase is primarily Kotlin, leveraging Okio for I/O and Gradle for building. The repository exhibits exceptionally high craftsmanship. It implements complex graph algorithms (dominator trees, multi-strength BFS reachability, squarified treemap layout) with clear, well-tested code. It solves hard engineering problems like sorting data larger than 2GB (PagedByteArrayTimSort) and building memory-efficient indexes. While actively maintained, the codebase shows some technical drift with deprecated APIs and TODOs, but the core algorithms and architecture are timeless and robust. It is a prime example of a well-engineered, domain-specific analysis tool.
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.
EinkBro is a full-featured Android WebView-based browser specifically optimized for e-ink displays. It provides a rich reading experience with features like ad blocking (via a native C++ engine forked from Brave), paragraph-level translation (Google/DeepL/OpenAI/Gemini), text-to-speech (Edge TTS, system TTS, Web Speech polyfill), reader mode, EPUB reading, user script support, and AI agent capabilities (chat-with-web, multi-step browsing tasks). The architecture is a monolith Android app with three Gradle modules (app, ad-filter, adblock-client) using Kotlin, Jetpack Compose, Koin DI, Room database, and OkHttp. Key entry points include BrowserActivity (main browser), EBWebView (custom WebView wrapper), and various delegate classes for tab management, translation, AI chat, and gesture handling. The codebase demonstrates strong engineering practices with extensive unit tests, a well-structured delegate pattern, and several reusable components such as type-safe SharedPreferences delegates, a standalone PDF parser, and a jsdom-based test harness for WebView-injected JavaScript.
Rush is a cross-platform lyrics application built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, and Desktop (JVM). Its primary function is to search for, display, and share synced lyrics (line-synced and syllable-synced) from multiple sources including LrcLib, Genius, and a custom LyricsPlus API. The app integrates with the system's media playback to auto-detect the currently playing song and fetch matching lyrics. Notable features include romanization of lyrics for non-Latin scripts (Japanese, Korean, Hindi, Punjabi, Cyrillic) via a dedicated Android library, customizable visualizers (wave, gradient, hypnotic) for lyrics backgrounds, and a variety of share card styles (Spotify, Rushed, Brat, etc.). The architecture follows MVVM with Koin for dependency injection, Room for local persistence, DataStore for preferences, and Ktor for networking. The codebase is well-modularized with shared core, logic, and UI modules, though significant parts of iOS and Desktop support remain stubbed or incomplete.
FlorisBoard is a free and open-source Android keyboard (IME) application written in Kotlin with Jetpack Compose. In production it functions as a fully-featured soft keyboard service (FlorisImeService extends InputMethodService) with clipboard history management (Room-backed), emoji input with search and history, multi-language keyboard layouts (50+ locale JSON layouts), a custom extensions system for themes/keyboards/language packs, and a custom stylesheet-based theming engine called Snygg that powers all IME UI styling. The app also includes a settings activity (FlorisAppActivity) with ~30 configuration screens, a spell-checker service, backup/restore infrastructure, incognito mode, and a native Rust/JNI library scaffold for performance-critical work. The architecture is a multi-module Gradle build (:app, :lib:android, :lib:compose, :lib:kotlin, :lib:native, :lib:snygg) with a clear separation between the Android-specific app layer and reusable common KMP libraries.
Material Files is a sophisticated, open-source Android file manager built with Kotlin and Material Design principles. Its core architecture is a custom implementation of the Java NIO2 file system API (`java.nio.file.spi.FileSystemProvider`), providing a unified abstraction over multiple backends: the local Linux filesystem (accessed via JNI syscalls), Android's proprietary Documents/Content providers, and remote network protocols including SMB, SFTP, FTP, and WebDAV. The UI is constructed from Android Fragments, RecyclerView adapters, and custom Material Design widgets, orchestrated by a ViewModel/LiveData pattern for reactive state management. The application goes far beyond basic file browsing. It features a comprehensive background file job service for copy, move, delete, and archive operations with progress tracking and conflict resolution. It includes a built-in FTP server, an image viewer with EXIF support, a text editor, and deep file property inspection (APK metadata, audio/video tags, checksums, POSIX permissions, and SELinux context). Root access is achieved through a separate process communicated via AIDL (Android Interface Definition Language), demonstrating a sophisticated IPC architecture for privilege escalation. The codebase is actively maintained by a single developer, with recent commits and a clear version history. However, it suffers from high technical drift due to its heavy reliance on Android's internal, undocumented, and frequently changing APIs (e.g., `android.system`, `android.os.storage`). The extensive `compat` package is a testament to the constant battle against platform evolution. This makes the project fragile and high-risk for long-term maintenance without dedicated effort. Despite its overall complexity, the repository contains several genuinely reusable, high-craftsmanship components. Standouts include the `ByteString`/`ByteStringPath` classes for handling non-UTF-8 filesystem paths, a generic `ListDiffer` algorithm, a robust `Stateful`/`DataState` state machine pattern, and clean implementations of throttling/debouncing. These components are self-contained and could be extracted for use in other Kotlin or Java projects. The overall quality score is 7.5, reflecting strong engineering and feature depth, balanced against significant platform-specific technical debt.
This is an Android application designed as a learning resource for Kotlin Coroutines. It provides a series of hands-on examples demonstrating common coroutine patterns in Android development, including single/parallel/series network calls with Retrofit, Room database operations, long-running tasks, timeout handling, and error handling strategies (try-catch, CoroutineExceptionHandler, supervisorScope). The architecture follows a simple MVVM pattern with ViewModel, LiveData, and a sealed UiState class. The code is straightforward and intended for educational purposes, with a clear separation of layers (API, database, UI). While it does not exhibit advanced or production-grade architecture, it serves as a practical reference for developers learning coroutines.
This is an Android application named 'Notifications Recovery' that captures, stores, and displays device notifications locally. It runs a NotificationListenerService to intercept all incoming notifications, parses their content (title, text, big text, conversation title, etc.), and persists them to an ObjectBox embedded database. It also detects when notifications are removed and marks them as deleted. The app provides multiple UI screens: a main list of all notifications with search/filter, a chat-style view for messaging apps (using Jetpack Compose), a pie chart for app-wise statistics, and a separate view for deleted notifications. It includes blacklist/whitelist filtering, encrypted ZIP export/import, biometric authentication, screenshot blocking, and three Android home screen widgets (latest, chat, and deleted notifications). The architecture is a monolithic Android app with a service layer, activities using XML layouts, and selected Compose screens. Dependencies include ObjectBox, MPAndroidChart, Zip4j, and AndroidX libraries. The codebase shows active maintenance but suffers from inconsistent version numbers (targeting unreleased SDK 37) and some code quality issues like threading concerns and deprecated API usage.
UKIKU is a feature-rich Android application for streaming and downloading anime episodes, built primarily in Kotlin with some legacy Java. It scrapes content from animeav1.com (and related sites) using Jsoup and custom JavaScript extraction, bypassing Cloudflare protection via a WebView-based mechanism. The app offers a comprehensive anime tracking experience: browsing a directory, searching, viewing details, watching episodes via ExoPlayer (with Chromecast and Android TV support), downloading (including HLS), managing favorites and watch history, queuing episodes, earning achievements, and syncing user data to Firebase Firestore or Dropbox. It also includes a gamified economy system (loli-coins) and extensive ad integration (AdMob, AppLovin). The architecture follows MVVM with Room database, WorkManager, and coroutines, but suffers from significant technical debt: duplicate UI layouts (material vs. non-material), deprecated libraries (Anko, RxJava, old MaterialDialogs), fragile scraping logic, weak encryption, and hardcoded API keys. Despite these issues, the app is functional and has a large user base (203 stars, 39 forks). It is not a data research project; it is a consumer Android application.