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.
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).
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
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.
Firemote is a Home Assistant custom dashboard card that emulates physical remote controls for a wide range of media devices including Amazon Fire TV, Apple TV, Chromecast, NVIDIA Shield, Roku, Xiaomi, and more. The card provides realistic visual remotes with extensive customization: over 330 app launcher shortcuts, button overrides via Home Assistant scripts or actions, multiple remote styles, and support for device-specific compatibility modes. It integrates with Home Assistant's Android Debug Bridge, Android TV Remote, Apple TV, and Roku integrations. The repository contains the compiled JavaScript card and supporting data files for device definitions and translations, but the source is distributed as a single minified bundle. It is actively maintained with a large community and frequent updates.
AnExplorer is a native Android file-manager application (package dev.dworks.apps.anexplorer) that exposes a Storage Access Framework-compatible DocumentsProvider layer over many storage backends: external/internal storage, USB OTG, root shell, FTP/FTPS, cloud storage (Google Drive, Dropbox, OneDrive, Box via CloudRail), app management, zip archives, recent files, and a note editor. It is a heavily customized fork of AOSP DocumentsUI: the core browsing state-machine, document stack, roots cache, recents persistence, and loader/cursor stack are AOSP-derived, with substantial product-specific additions for monetization, multiple build flavors, PIN security, settings, and Wear OS/TV support. The marketing site in web/ is a static Firebase-hosted page, not part of the application logic. The architecture is a classic Android monolith: Activities and Fragments drive the UI, Loaders and custom Cursor wrappers feed RecyclerView adapters, and each storage backend is implemented as a DocumentsProvider ContentProvider. Main entry points are DocumentsActivity and StandaloneActivity for browsing, plus the provider authority intents for the Storage Access Framework. External dependencies include AndroidX, Firebase Analytics/AdMob/Crashlytics, CloudRail, libaums for USB, Apache Commons Net for FTP, and an in-app billing library. Quality is mixed. The provider and cursor abstractions are reasonably flexible and a few utility components are genuinely reusable, but the codebase carries heavy technical drift: AGP 3.3 alpha, targetSdk 28, deprecated android.app.Fragment/AsyncTask/PreferenceActivity usage, duplicated flavor-specific classes, hardcoded ad and analytics identifiers, and third-party SDKs that are no longer actively maintained. It remains a functional, feature-complete consumer app rather than a modern engineering showcase.