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.
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.
DUNE is a specialized Android TV client application for the Jellyfin media server ecosystem. It functions as a media consumption interface optimized for remote control navigation, featuring video/audio playback, library browsing, live TV (DVR) management, and extensive user customization. The architecture is a monolithic Android application with modularized internal structure (app, playback, preference modules), utilizing a hybrid UI approach that combines Jetpack Compose for modern screens (preferences, overlays) with Android Leanback widgets for traditional TV browsing. The codebase demonstrates strong separation of concerns, particularly in the playback layer which abstracts media rendering logic from the UI. It relies heavily on the Jellyfin SDK for API communication and ExoPlayer (Media3) for media rendering.
SmartTube is a free, open-source Android TV YouTube client that replaces the official YouTube app with enhanced features like SponsorBlock integration, adjustable playback speed, 8K/HDR support, live chat, and no dependency on Google Services. The architecture is a modular Android application built on a heavily customized fork of ExoPlayer (v2.10.6, Amazon variant) for media playback, and AndroidX Leanback (v1.0.0) for the TV-optimized user interface. The codebase follows a presenter-view pattern with clear separation of concerns, using singleton presenters and view interfaces. Key entry points include SplashActivity, BrowseActivity, PlaybackActivity, and various settings dialogs. Data flows primarily from YouTube's unofficial API (via SABR streaming protocol) through custom ExoPlayer extensions, with additional integrations for SponsorBlock, DeArrow, remote control, and Google Drive backup. External dependencies include ExoPlayer (forked), Leanback (vendored), Glide, RxJava, WorkManager, and a few third-party UI libraries (chatkit, slidableactivity, filepicker).
NuvioTV is a full-featured Android TV media player application that aggregates content from Stremio-style addons, debrid services (Real-Debrid, Torbox, Premiumize), and torrent streaming via TorrServer. It provides a rich browsing experience with personalized continue-watching, library management, and cross-device watch progress sync through a Supabase backend. The application deeply integrates with tracking services (Trakt and Simkl) for scrobbling and history, and includes an extensive settings system for theme customization, playback controls, and addon management. Architecturally, it is a single-module Android app built with Kotlin, Jetpack Compose for TV (androidx.tv.material3), Hilt dependency injection, and a custom fork of AndroidX Media3 (ExoPlayer) with native components for Dolby Vision processing, subtitle sanitization, and frame-rate detection. The codebase follows MVVM with ViewModels emitting sealed UI states via StateFlow, and uses DataStore for per-profile preferences. It includes two build flavors (full with plugin runtime and updater, playstore with stripped features) and an extensive test suite covering sync logic, playback policies, and data migrations. The system's complexity lies in its multiple external integrations (addon protocol, debrid APIs, tracking providers, Supabase RPC) and the custom player pipeline that handles codec failover, subtitle merging, and adaptive bitrate control. While the code is generally well-structured with clean abstractions and reusable UI components, it suffers from moderate technical drift due to vendored AndroidX modifications, flavor divergence, and reliance on rapidly evolving third-party APIs.
Aerial Views is an Android TV screensaver (DreamService) that plays aerial videos and photos from multiple sources—Apple, Amazon, community feeds, local storage, Samba, WebDAV, Immich, Nextcloud Memories, and custom feeds. It provides a rich overlay system (clock, date, weather, metadata, now-playing, countdown, message API) and supports hardware vendor integrations (Projectivy, Philips TVs). The architecture follows a provider pattern with a central ScreenController orchestrating playback, overlays, and services. The codebase is actively maintained with extensive internationalization, unit tests, and CI/CD. While the provider abstractions are clean and extendable, the ScreenController is large and tightly coupled, and the app has moderate technical drift (deprecated APIs, unusual compileSdk 37). Overall it's a well-engineered, feature-complete application for its niche.
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.
CloudStream is an Android media aggregation application that streams and downloads movies, TV series, and anime via a plugin-based provider system. The app has no built-in content; all media sources are provided by community extensions implementing `MainAPI` and `ExtractorApi` interfaces. The architecture comprises a Kotlin Multiplatform library defining plugin APIs and an Android app with ExoPlayer/Media3 playback, download manager, sync with tracking services (MAL, AniList, Kitsu, Simkl, Trakt), multi-source subtitle fetching, Chromecast support, and adaptive phone/TV UI. Content acquisition relies on web scraping: over 100 built-in extractors parse video hosting sites, often using JavaScript deobfuscation (via a custom JS interpreter) and AES decryption. The plugin system supports repository-based distribution, versioning, and binary compatibility checks. While the codebase is actively maintained and demonstrates good engineering practices (MVVM, coroutines, custom adapters), many extractors are brittle due to external site dependencies, and some modules exhibit tight coupling and deprecated API usage.
Litube is an advanced Android WebView wrapper for YouTube, providing ad-free playback, native video/audio downloading, background play, Picture-in-Picture (PiP), SponsorBlock integration, and a customizable extension system. It uses a hybrid architecture where YouTube's mobile site is rendered in a WebView via `YoutubeFragment`, while video playback is handled natively using AndroidX Media3 (ExoPlayer) with custom `YoutubeHttpDataSource` for streaming. The app includes a full-featured download manager (multi-threaded chunked downloads, audio/video merging with MP4Parser), a queue system, a mini-player, and gesture controls. It reverse-engineers YouTube's streaming protocols using the NewPipe Extractor and generates PoTokens through a WebView-based mechanism to bypass bot detection. The application is structured as a single-module Gradle project with Dagger Hilt for dependency injection, MMKV for key-value storage, and Gson for serialization. It has extensive JavaScript injection (`init.js`) to manipulate the YouTube DOM for features like hiding Shorts, displaying dislikes, and injecting a custom settings page. While primarily an application, it includes data extraction components (stream catalog, delivery analysis) that could be considered a research layer for understanding YouTube's streaming infrastructure.
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.
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.