Compressor is a native Android video compression application built entirely in Kotlin using Jetpack Compose and Material3 for the UI, and Android's Media3 Transformer for the actual encoding. It does not rely on FFmpeg; instead, it leverages hardware-accelerated codec APIs (H.264, H.265, AV1) to achieve fast, lightweight compression. The app follows a single-activity architecture with a ViewModel managing the full lifecycle: video selection via SAF (Storage Access Framework) or share intents, track probing to determine source properties, building a compression plan based on user-defined presets or target file size, executing the transformation, and saving the output to the gallery or a custom folder. The codebase is well-structured with clear separation between UI screens, reusable composable components (InfoRow, CheckboxRow, SelectionChip, etc.), utility classes for hardware detection and file operations, and a theme system that supports dynamic colors and Android 16 tokens. It includes comprehensive unit tests for the ViewModel, utilities, and audio processor, as well as CI/CD workflows and fastlane metadata for Play Store deployment. The project demonstrates strong Android engineering practices, with attention to edge cases (device-specific workarounds for MediaTek, Huawei, Pixel), fallback logic in audio encoding, and a customizable filename token system. While the core compression logic is tightly coupled to the app's domain, several utility modules and UI components are designed with reusability in mind and could be extracted for other Android media projects.
This repository is an Android TV application (役čŚTV) that provides a comprehensive media center experience for streaming Video-on-Demand (VOD) and live television. It features a plugin-based content aggregation system using spiders written in Java, Python (via Chaquopy), and JavaScript (via QuickJS), allowing users to browse and play content from multiple external sources. The application supports multiple player engines (ExoPlayer and mpv), hardware/software decoding, subtitle and danmaku (bullet comment) overlays, DLNA casting (both sender and renderer), and a local HTTP server for remote control and file sharing. Architecturally, the project is a multi-module Gradle build with a shared core library (catvod) providing network utilities, cryptography, and data models. The main app module contains two UI tracks: 'leanback' for TV remote control navigation and 'mobile' for touch-based phone interaction, both sharing common logic under app/src/main. The system uses an event-driven architecture with EventBus, a Room-based SQLite database for persistence, and a ViewModel pattern for reactive UI updates. External content sources are integrated through a standardized Spider interface, with loaders for JAR, Python, and JavaScript plugins. Key features include a sophisticated playback controller with fallback policies, preloading, and history management; extensive audio/video effect pipelines (equalizer, loudness normalization, color adjustment); danmaku search and display; EPG (Electronic Program Guide) with timezone-aware parsing; and a comprehensive settings system covering player, decoding, subtitles, and network configuration. The project also includes a documentation website built with Next.js, providing developer guides for the spider API and local HTTP API.
Phocid is a full-featured offline Android music player built with Jetpack Compose and Material3, targeting Android 11+. It serves as a modern replacement for Phonograph, offering extensive customization of themes, artwork colors, layouts, and playback behavior. The application manages a local music library by scanning MediaStore and optionally using JAudioTagger and OpusMetadataIo for advanced metadata extraction. It supports playback via Media3 ExoPlayer with custom shuffle, repeat, speed/pitch control, and a sleep timer. The UI includes a tabbed library view (tracks, albums, artists, genres, folders, playlists), a player screen with artwork, synced lyrics (LRC), and a queue, plus home screen widgets and Android Auto integration. Playlist management features M3U import/export with relative paths and bidirectional sync using file timestamps. The codebase is well-structured with clear separation of concerns: data layer (LibraryIndex, Playlist, Preferences), service layer (PlaybackService, PlayerManager), UI components (custom scrollbar, swipe-to-dismiss, carousel, dialogs), and utility modules (AsyncCache, SaveManager, StateFlow extensions). It includes unit tests for core logic (lyrics parsing, playlist I/O, search, sorting, caching) and uses Kotlinx Serialization for persistence with upgrade paths. The architecture follows a single-activity pattern with Compose navigation and a ViewModel-driven state management. While primarily an application, it contains reusable data engineering patterns such as generic persistence, concurrent caching, and locale-aware sorting that could be extracted for other projects.
Chocola is an offline music player for Android built with Kotlin and Jetpack Compose. It provides a full-featured music experience: library browsing by albums, artists, playlists, and folders; playback with equalizer, speed/pitch control, sleep timer, and shuffle/repeat modes; synced lyrics display and editing; metadata editing; Android Auto support; and home screen widgets. The app uses Material 3 design with a distinctive 'cute' theme, custom navigation, and extensive localization. The architecture follows a typical Android MVVM pattern with Room for playlist persistence, DataStore for preferences, ExoPlayer/Media3 for playback, and Koin for dependency injection. It scans local media via MediaStore and SAF, applies configurable filters (minimum duration, hidden tracks, whitelisted folders), and uses TagLib for metadata editing. While the codebase is well-organized and demonstrates solid Android engineering, it relies heavily on experimental Compose APIs and a custom navigation library, which introduces some technical drift risk. Overall, it's a mature, actively maintained open-source project suitable for reuse of specific UI components and data-layer patterns.
SimpMusic is a production-grade Kotlin Multiplatform music player for Android and desktop (JVM) that streams from YouTube Music's undocumented backend. The codebase is organized around a shared Compose Multiplatform UI module (composeApp), Android entry points (androidApp), a desktop entry point (desktopApp), and optional feature modules for Google Cast, Last.fm scrobbling, and crash reporting. A separately referenced core submodule supplies domain and media-service logic. Internally it uses MVVM with Koin dependency injection, Repository interfaces backed by Room entities and DataStore, StateFlow-based ViewModels, and a large custom Compose component library covering home feed, library management, playlist sync, fullscreen player, lyrics, equalizer, podcasts, Android home-screen widgets, and a desktop mini-player. The app is shipped as a packaged consumer application with Play Store metadata, GitHub Actions, fastlane changelogs, and build variants that swap real integrations for empty stubs in FOSS builds.
MonsterMusic is a full-featured Android music player application built with Jetpack Compose, Material3, and Media3 (ExoPlayer). It provides local music playback with extensive audio effects including a 10-band equalizer, echo/reverb, spatial audio (virtual surround), pitch/speed control, and real-time FFT visualization. The app reads audio metadata via a bundled copy of the JAudioTagger library, supporting ID3v2, MP4, FLAC, Ogg, WAV, AIFF, and WMA formats. It includes synchronized lyrics display (LRC/SRT), playlist management (M3U import/export), sleep timer, home screen widget, and a drawer-based UI for browsing songs, albums, artists, genres, and folders. The codebase is a hybrid of Kotlin (app logic) and Java (embedded library), with moderate architectural separation via ViewModel, Repository, and Room persistence. While feature-rich, the project shows signs of stalled maintenance; the embedded metadata library is large and may have drifted from upstream, and several Compose APIs are marked experimental. The app is functional but not production-polished, with some dry code and unfinished fragments.