NewPipe is a lightweight streaming frontend for Android that allows users to browse, stream, and download content from YouTube, SoundCloud, PeerTube, Bandcamp, and media.ccc.de without using official APIs or requiring a Google account. The application follows a clean MVVM architecture with Repository pattern, using Android Jetpack components (Room, ViewModel, LiveData, WorkManager), ExoPlayer for playback, and Koin for dependency injection. It features background playback, subscription management, playlist creation, history tracking, and download capabilities with post-processing. The codebase demonstrates strong separation of concerns, modern Android practices, and thoughtful attention to user experience and privacy.
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.
Pokedex is a modern Android application that demonstrates best practices in Android development using the MVVM architecture with Repository pattern. The app fetches and displays Pokémon data from the PokeAPI, featuring offline-first capabilities through Room database caching, pagination for efficient data loading, and smooth transition animations between list and detail views. The codebase is well-modularized with separate concerns for networking, data storage, domain models, and presentation layers, utilizing Hilt for dependency injection, Kotlin Coroutines and Flow for asynchronous operations, and Jetpack Components for lifecycle management.
Jetpack Android Starter is a production-ready template for modern Android development built on Jetpack Compose and clean architecture principles. It provides a comprehensive foundation with feature modules for authentication, home, profile, and settings, integrated with Firebase for authentication, Firestore, and Crashlytics. The architecture follows a two-layer UI/Data pattern with Repository pattern, Hilt dependency injection, Room for local storage, DataStore for preferences, and WorkManager for background synchronization. UI is built with Compose Material 3, featuring custom reusable components and type-safe navigation using Kotlin Serialization. The template includes CI/CD via GitHub Actions, automated dependency updates, documentation generation, and performance optimizations like baseline profiles. It demonstrates strong engineering practices with clear separation of concerns, testable architecture, and reusable patterns that solve common Android development challenges.
This is the official Bitwarden password manager for Android, a production-grade Kotlin application with a modular monorepo structure. It implements a full-featured password manager including vault management (ciphers, folders, collections, sends), autofill (standard and accessibility-based), FIDO2/WebAuthn passkey support, TOTP authenticator, password/username generator, secure credential exchange (CXF), and enterprise features like SSO, Duo, and policy enforcement. The architecture follows an MVVM pattern with Jetpack Compose UI, Dagger/Hilt dependency injection, Room SQLite for local persistence, Retrofit/OkHttp for networking, and the Bitwarden SDK for cryptographic operations. The codebase is organized into multiple Gradle modules: `app` (main app), `authenticator` (standalone TOTP app), `authenticatorbridge` (AIDL-based cross-app communication), `network` (API client), `data` (data sources and repositories), `ui` (reusable Compose components), `core` (platform utilities), `cxf` (credential exchange), and `testharness` (Credential Manager API testing). Key entry points include `MainActivity`, `CredentialProviderActivity`, `AuthCallbackActivity`, and `BitwardenApplication`. Data flows involve syncing vault data from Bitwarden servers to local Room databases, processing autofill requests from other apps via Android's Autofill and Credential Manager frameworks, and securely sharing TOTP secrets between the main app and authenticator app via the encrypted bridge. External dependencies include the Bitwarden SDK, AndroidX libraries (Compose, Navigation, Room, Biometrics, Credentials, etc.), Retrofit, OkHttp, kotlinx.serialization, and optional Firebase for push notifications and crash reporting.
The DuckDuckGo Android repository is a privacy-focused mobile browser application featuring tracker blocking, ad blocking, password management, VPN protection, and AI chat capabilities. It employs a modular architecture with feature-specific modules (app, browser, autofill, sync, privacy-*, network-protection, etc.) built using modern Android Jetpack components. The codebase utilizes Dependency Injection via Dagger/Hilt with Anvil annotations for code generation, follows MVVM patterns with ViewModels and LiveData/Flow, and implements a robust plugin system via @ContributesPluginPoint annotations for extensibility. Feature flags control gradual rollouts and A/B testing, while Room databases handle local persistence for settings, credentials, and usage statistics. The application emphasizes user privacy through encrypted storage, tracker detection networks, and transparent privacy dashboards.
ReVanced Manager is an Android application that applies custom patches to Android APKs using the ReVanced Patcher engine. It provides a user interface for downloading patch bundles, selecting and configuring patches, patching applications (including a background patcher service), signing the resulting APKs, and installing them. The app is built with modern Android technologies: Jetpack Compose for UI, Room for local persistence, Koin for dependency injection, Ktor for networking, and WorkManager for background tasks. It follows an MVVM architecture with a repository pattern and supports root-based installation via Magisk modules. The application manages a complex state of patch selections, downloaded apps, installed apps, and options through a Room database with schema migrations. It includes a downloader plugin system for acquiring APK files from various sources, automatic update checks for the manager itself, patches, and downloaders, and extensive localization support via Crowdin.
YTDLnis is a feature-rich Android application that serves as a graphical frontend for yt-dlp, enabling users to download video and audio from over 1000 websites. The app follows the MVVM architecture with Room database for local persistence, WorkManager for background download tasks, and a repository pattern for data access. It provides a comprehensive download management system including queue management, scheduling, format selection, metadata embedding, chapter splitting, SponsorBlock integration, and support for custom yt-dlp commands. The application also includes a built-in terminal emulator for advanced users, cookie management, YouTube PoToken generation, and an observe-sources feature for monitoring channels or playlists for new content. The codebase is well-organized into UI fragments, viewmodels, repositories, and utility classes, with extensive use of Kotlin coroutines and Android Jetpack components. While the app is actively maintained and demonstrates solid engineering practices, some modules like UiUtil.kt are monolithic and tightly coupled, and the heavy reliance on external tools (yt-dlp, FFmpeg, Python) introduces ongoing maintenance risks.
SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
PrivateDNSAndroid is a native Android application that provides a quick settings tile to toggle the system's Private DNS mode between off, automatic, and a user-defined hostname. It allows users to manage a list of DNS servers (add, edit, delete, reorder) stored in a Room database, and cycle through them via the tile or shortcuts. The app requires the WRITE_SECURE_SETTINGS permission, which can be granted via Shizuku or ADB. The architecture follows standard Android patterns: Activities, Services (TileService, ShortcutService), ViewModel, Repository, and Room DAO. The UI uses both traditional XML layouts and Jetpack Compose for dialogs. The codebase is well-structured, uses modern libraries (Kotlin Coroutines, Room, Compose, Material 3), and includes features like settings export/import and multi-language support. It is a focused, single-purpose utility app with clean separation of concerns.
NoWakeLock is a production-grade Android Xposed module and companion app that provides granular control over system power management. It intercepts and selectively blocks or limits WakeLocks, Alarms, and Services at the Android framework level via Xposed hooks, enabling users to reduce battery drain. The system consists of two processes: an Xposed module running in the system_server process that performs the actual interception using both legacy (XposedBridge) and modern (libxposed API 102) APIs, and a standard Android application with a Jetpack Compose UI that allows users to configure per-app and per-item blocking rules, view real-time statistics, and manage settings. Data flows from the Xposed hooks through a ContentProvider-based IPC (XProvider) into a dual Room database architecture (AppDatabase for configuration, InfoDatabase for runtime events). The app features Material Design 3, multi-language support, backup/restore via JSON, multi-user profiles, module health diagnostics, and hot reload support for modern Xposed frameworks. The codebase demonstrates a clean MVVM architecture with Koin dependency injection, Kotlin Coroutines/Flow for reactive data flow, and comprehensive unit/instrumentation tests. While primarily a standalone application, several core concurrency utilities (BoundedEventQueue, ReloadableEventConsumer, WakelockRegistry) could be extracted and reused in other Android or system-level projects.
WanAndroid is a polished, feature-rich Android client for the WanAndroid platform (wanandroid.com), a Chinese community for Android developers. The application provides comprehensive browsing of articles, projects, WeChat articles, knowledge trees, navigation, Q&A, book tutorials, and daily news aggregation from multiple Chinese sources. It implements a classic MVP architecture with a modular project structure (app, basic/core, basic/ui, basic/utils, basic/l10n, component/ad). Key entry points include SplashActivity and MainActivity (hosting a bottom-tab fragment container). The system heavily leverages OkHttp/RxHttp for network requests to the WanAndroid REST API, DiskLruCache for offline caching, Room for local persistence (read-later and read-history), and EventBus for cross-component events. Beyond vanilla browsing, it features a custom WebView subsystem (WebInstance, WebContainer) with resource interception, offline HTML/ CSS caching, a reading mode using readability4j and Jsoup, and JavaScript injection for image clicks. It also includes text-to-speech (TTS) via Android TTS engine with AI-powered summarization, biometric quick login, QR code scanning, card/article sharing, a coin/ranking gamification system, and in-app updates. External dependencies include Google AdMob for ads, optional AI provider APIs (e.g., DeepSeek), and the WanAndroid server endpoints. The codebase is a mix of Java and Kotlin, with several reusable custom UI components like BottomDrawerLayout, ImagePreviewView, CollectView, and custom pull-to-refresh headers with Chinese poetry.
An Android audio recording and playback application with two coexisting architectures: a legacy Java MVP system (V1) and a modern Kotlin Compose MVVM system (V2). The app supports recording in M4A/AAC, WAV, and 3GP formats with configurable sample rate, bitrate, channel count, and audio source. It features waveform visualization during recording and playback, file management (rename, bookmark, trash, import/export), broken-record recovery, and a customizable name-format builder. The V2 codebase uses Jetpack Compose, Hilt dependency injection, Room database, ExoPlayer, and coroutines, while V1 uses Android Views, SQLite, and manual DI. The dual-codebase design adds complexity and maintenance risk, but the V2 components are well-architected with a clean unidirectional data flow and reusable patterns for media handling and UI state management. The project has extensive localization (18 locales), fastlane metadata for Play Store, and a custom home-screen widget.
AdAway is an open-source Android ad-blocking application that provides two methods for blocking ads: modifying the system hosts file (requires root) and a local VPN-based DNS filter. The app downloads and manages multiple hosts sources from URLs, parses them into a local Room database, and applies the blocklists either by writing to /etc/hosts or by intercepting DNS queries through a local VPN service. The VPN mode maps real DNS servers to fake addresses, forwards allowed queries, and returns blocked or redirected responses. The architecture follows MVVM with LiveData, ViewModel, and Room, and includes background workers for periodic updates. The app bundles a legacy native C library (tcpdump/libpcap) for packet capture, used for DNS logging. The codebase is actively maintained, with frequent commits and releases, but some native components are outdated and the VPN implementation may have compatibility issues on newer Android versions.
Repository is a production Android application for Mixin Network, combining a cryptocurrency wallet with a messenger. It integrates with Mixin API (api.mixin.one) and Blaze messaging, supports transfers, swaps, web3 trades, perps, fiat money, and market analytics. The app is built with Kotlin, uses MVVM with ViewModels and Flows, Room for persistence, and a mix of Jetpack Compose and legacy View-based UI. A separate query-codegen Gradle module generates type-safe query code, and release automation includes Fastlane, Docker build box, and APK signature verification.
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.
Android Debug Database is an Android library that provides a web-based interface for debugging databases and shared preferences in Android applications. When included in an app's debug build, it starts a lightweight HTTP server that serves a web UI allowing developers to inspect databases, run SQL queries, edit data directly, and manage shared preferences. The architecture consists of a core library (debug-db-base) that handles server logic and database interactions, with optional modules for encrypted database support (debug-db-encrypt) and sample applications demonstrating usage. The system uses a client-server model where the server runs inside the Android app and the client is a standard web browser connecting via HTTP to localhost. Key features include support for SQLite databases, Room databases (including inMemory), SharedPreferences, and SQLCipher-encrypted databases, with a responsive web interface built using Bootstrap, jQuery, and DataTables.
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.