This repository is the core codebase for uni-app-x, a next-generation cross-platform mobile development framework. Unlike the traditional WebView-based uni-app, this version utilizes UTS (Uni-app TypeScript) to compile directly to native code (Swift/Kotlin/ArkTS) for iOS, Android, and HarmonyOS, alongside Web and Mini-program support. The architecture is a monorepo structure with a plugin-based system (`uni_modules`) that allows modular distribution of native SDKs and cloud functions. It bridges JavaScript/TypeScript logic with native OS capabilities through a custom runtime engine and UTS compiler, enabling high-performance native rendering and hardware access. The system operates as a full-stack framework, including a CLI for project scaffolding, a compiler pipeline (Vite/Webpack integration), and a serverless cloud backend (`uniCloud`) for authentication, payments, and data management. Key data flows involve client-side code compilation into platform-specific binaries, communication via a native bridge (JSBridge/UTS), and serverless function execution on cloud providers (Aliyun, Tencent, Alipay). The framework relies heavily on embedded native dependencies (Lottie, IJKPlayer, TencentLBS) and maintains a complex plugin ecosystem to abstract platform differences. While the codebase demonstrates high craftsmanship in native rendering engines and plugin architecture, it carries significant maintenance overhead due to platform fragmentation and the need to keep embedded native SDKs synchronized with OS updates. The UTS language and compiler are custom-built, introducing a layer of technical debt and drift risk as the ecosystem evolves. The project is actively maintained with frequent updates to SDKs and compiler stability, but the complexity of supporting multiple platforms simultaneously creates a medium level of technical drift.
QtScrcpy is a cross-platform desktop application for mirroring and controlling Android devices over USB or Wi-Fi, implemented as a C++/Qt reimplementation of scrcpy. The codebase is a conventional Qt Widgets monolith: main.cpp initializes the application and main dialog, the UI drives ADB through QProcess to deploy and run a server component on the device, incoming video is decoded with FFmpeg and rendered with OpenGL or Metal on Apple Silicon, and keyboard/mouse/touch events are forwarded back through the scrcpy control protocol. It also provides custom JSON key mappings, group control for broadcasting input to multiple devices, audio forwarding via a bundled sndcpy APK, system tray integration, single-instance enforcement, dark styling, and translations for Chinese, English, Japanese, and Korean. The most reusable parts of the repository are intentionally small, isolated UI and utility components rather than the main controller logic. KeepRatioWidget preserves a child's aspect ratio, MagneticWidget snaps a toolbar to window edges, MouseTap provides a clean cross-platform abstraction over Win/X11/Cocoa mouse-grabbing APIs, SingleInstance uses a local socket to prevent duplicate launches, and IconHelper loads Font Awesome icon glyphs. The video rendering widget demonstrates hand-written OpenGL shaders for YUV-to-RGB conversion, and the encoder preset registry hints at a factory-style extensibility pattern. Maintenance is active, with recent commits, release tags, and CI workflows for Windows, macOS, and Linux. However, there is measurable technical drift: the code contains many Qt5/Qt6 conditional blocks, deprecated Qt APIs such as QRegExp appear in the UI, the Ubuntu CI container is older (20.04 / Qt 5.15.2), and the README heavily promotes the author's commercial successors. The project is not a data/research repository; it is a practical desktop tool with no data pipelines, notebooks, or analytical artifacts.
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.
objection is a runtime mobile exploration toolkit powered by Frida, designed for security testing of iOS and Android applications without requiring jailbreak or root access. It provides an interactive REPL (objection explore) that lets security researchers bypass SSL pinning, dump keychain/keystore data, monitor cryptographic operations, inspect heap memory, hook methods, and bypass jailbreak/root detection — all by injecting a Frida agent into the target process. Architecture: The Python backend handles CLI commands, device state management, and patching (injecting Frida gadget into IPA/APK files). The TypeScript agent running inside the mobile app exports RPC methods for platform-specific features (Android: hooking, keystore, intents; iOS: keychain, crypto, biometrics). Communication happens over Frida's bi-directional transport. A Flask API server exposes RPC and script endpoints for remote control. The system uses a centralized state layer (connection, device, jobs) and a plugin system for extensibility. Key entry points: 'objection explore' (REPL), 'objection patchapk'/'objection patchipa' (binary patching), 'objection api' (API server), and the agent entry point in 'agent/src/index.ts'. External dependencies include frida, frida-tools, frida-fs, frida-screenshot, Flask, apktool, and GitHub API for gadget downloads. The codebase is well-structured for mobile security automation but shows some drift with deprecated CLI flags, Python 2 compatibility checks, and TODOs for advanced hooking targets.
Onsen UI is a comprehensive mobile UI framework for building hybrid mobile apps and progressive web apps (PWAs) with native-like interfaces. The repository is a monorepo containing a core library built on Web Components, CSS components with iOS and Material Design theming, and official bindings for React, Vue 2, Vue 3, Angular 2+, and legacy AngularJS. The core defines custom HTML elements (e.g., `<ons-navigator>`, `<ons-tabbar>`, `<ons-dialog>`) that encapsulate mobile-specific UI patterns such as navigation stacks, tab bars, side menus, pull-to-refresh, lazy lists, and various form controls. The CSS component library provides a consistent, themable styling layer via CSS custom properties and BEM-like modifier classes. Framework bindings wrap these core elements for seamless integration with modern frontend frameworks. The repository also includes example applications, a CSS component previewer, and extensive documentation schemas. While the framework is mature and feature-rich, it shows signs of technical drift with deprecated APIs, multiple legacy binding packages, and a complex build infrastructure. It is actively maintained but appears to be in a stabilization phase rather than rapid development.
Hippy is a cross-platform mobile application framework developed by Tencent that enables developers to build native mobile apps using JavaScript with React or Vue. It provides a JS driver layer that communicates with native renderers on Android, iOS, OpenHarmony, and Web via a bridge system. The architecture is modular: a DOM layer manages the virtual tree and layout (using Taitank or Yoga), native renderers create platform-specific UI components, and a virtual file system (VFS) handles resource loading. The framework includes a full devtools backend implementing Chrome DevTools Protocol for debugging, performance monitoring, and DOM inspection. Key entry points include the JS bootstrap (hippy.js), native engine managers (HippyEngine on Android, HippyBridge on iOS), and the JS framework adapters (hippy-react, hippy-vue, hippy-vue-next). External dependencies include V8, Hermes, JSC, or JSH JavaScript engines, and platform-specific SDKs (AndroidX, UIKit, ArkUI). The codebase is large and actively maintained, with multiple renderer implementations and both Vue 2 and Vue 3 support, though some duplication and deprecated code exist.
FirebaseUI-Android is an open-source library providing pre-built UI components for Firebase Authentication, Realtime Database, Cloud Firestore, and Cloud Storage. It is a multi-module Android library published on Maven Central. The primary module, `firebase-ui-auth`, has been rewritten in Jetpack Compose with Material 3, offering a high-level composable (`FirebaseAuthScreen`) and a Kotlin DSL for configuration. It supports 12+ identity providers (Google, Facebook, Email, Phone, Apple, etc.), multi-factor authentication (SMS/TOTP), credential linking, anonymous upgrade, and email link sign-in. The `firebase-ui-database` and `firebase-ui-firestore` modules provide RecyclerView adapters with paging support (AndroidX Paging 3) for displaying Firebase data. The `firebase-ui-storage` module integrates with Glide for loading images from Firebase Storage. A demo app and end-to-end tests against the Firebase Auth Emulator are included. Architecturally, the library is split into separate Gradle modules: `auth`, `database`, `firestore`, `storage`, `common`, and `lint`. The auth module uses Kotlin coroutines, StateFlow, and a sealed class state machine (`AuthState`) to manage authentication flows. The database/firestore modules are older Java-based implementations using lifecycle-aware adapters and observable arrays. The library maintains a version catalog (libs.versions.toml) with modern dependencies (Kotlin 2.4.10, AGP 9.3.0, Compose BOM 2026.06.01). Key entry points include `FirebaseAuthScreen` (Compose), `FirebaseAuthUI` (singleton for sign-out/delete/auth state), `AuthFlowController` (Activity-based alternative), `FirebaseRecyclerAdapter`/`FirestoreRecyclerAdapter`, and `FirebaseImageLoader` (Glide integration). The primary data flows involve Firebase SDKs for authentication, database listeners, and image loading. The library is designed to be embedded in host Android apps, handling complex auth flows with minimal developer effort. The codebase demonstrates strong craftsmanship in the auth module’s state machine and Compose UI, but shows signs of technical drift due to mixed UI generations (legacy XML layouts alongside new Compose), some deprecated API usage (e.g., `fetchSignInMethodsForEmail`, `startActivityForResult`), and incomplete localizations. The database/firestore modules are mature but use older patterns. Overall, the library is well-structured and actively maintained, with a beta version (10.0.0-beta04) indicating ongoing development.
ObjectBox Java is an open-source, embedded NoSQL database library for Java and Kotlin, targeting Android, JVM, and desktop platforms. It provides a high-performance, native-backed object persistence engine with type-safe querying, reactive data observation, object relations (ToMany/ToOne), vector search via HNSW indexes, and optional client-server or mesh peer-to-peer synchronization. The code is organized into multiple Gradle modules including a core `objectbox-java` module with JNI bindings, an annotation API (`objectbox-java-api`), Kotlin extensions, RxJava 2/3 adapters, Android-specific integrations (LiveData, Admin web UI, Paging DataSource), and a mesh sync module using Google Nearby Connections. The architecture is library-centric with a clear separation between Java-facing API, internal serialization (vendored FlatBuffers), and native runtime. Extensive unit and integration tests cover core CRUD, transactions, queries, relations, sync, and error handling. The repository is actively maintained with a version 6.0.0-beta, publishes to Maven Central, and uses multi-platform CI (GitLab, Jenkins). While the codebase includes some legacy APIs and generated FlatBuffers code, the core abstractions exhibit solid software engineering practices with reusable patterns for reactive subscriptions, property converters, and cross-platform native library loading.
This repository is a GitHub template for bootstrapping Kotlin Android projects with a modern, opinionated build setup. It provides a multi-module structure (app, library-android, library-kotlin, library-compose) with pre-configured static analysis via detekt, CI/CD via GitHub Actions, and publishing to Maven Central. The codebase demonstrates best practices for Gradle Kotlin DSL, version catalogs, and precompiled script plugins. The sample modules include a simple factorial calculator to illustrate cross-module dependencies and testing patterns (unit, instrumentation, and Compose UI tests). While the template is not a production application itself, it serves as a solid foundation for new Android projects, emphasizing code quality and automation from the start.
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.
AppUpdater is a multi-module Android library that provides in-app update functionality: it checks a remote version, downloads the APK, shows progress via notification or dialog, and installs the APK across Android versions. The core `app-updater` module contains the update orchestration, download/install services, notification handling, and file/checksum utilities; the `app-dialog` module provides a ready-made update dialog; the `app` module is a sample. The main entry point is the `AppUpdater` builder/facade, which accepts an `UpdateConfig` and optional custom parser/strategy implementations, so consumers can plug in their own update-info JSON schema.
This is an Android application that serves as a GUI client for XTLS/Xray-core, a proxy/VPN tool. The app provides a comprehensive interface for managing proxy profiles, subscription links, and VPN configurations. It supports both standard VPN mode (using tun2socks) and transparent proxy mode (requiring root). The architecture follows MVVM with Room database for persistence, coroutines for async operations, and a native Go library (XrayCore) for core proxy functionality. The codebase is well-structured, using modern Android development practices (Kotlin, Jetpack libraries, Material Design 3). It includes features like QR code scanning, clipboard import, link management with auto-refresh, per-app routing, and a quick settings tile. The app is actively maintained with frequent updates and a CI/CD pipeline for release builds.
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.
Grazel is a Gradle plugin that migrates Android projects from Gradle to Bazel build systems. It analyzes Gradle project configuration, extracts Android-specific information (dependencies, variants, resources, manifest), and generates equivalent Bazel BUILD and WORKSPACE files. The plugin supports incremental migration, allowing parts of a project to use Bazel while others remain on Gradle. Architecture follows Gradle plugin conventions with modular separation: core plugin implementation, extension points for configuration, dependency analysis/resolution components, Android-specific extraction logic, Bazel rule generation using a type-safe Kotlin DSL for Starlark, and task management for orchestrating the migration process. Dependency injection via Dagger/Hilt ensures loose coupling and testability.
Live Photo Converter is a cross-platform application for processing Android Live Photos (MVIMG files). It provides a modern GTK4/LibAdwaita graphical interface, a set of command-line tools, and a shared library (`liblivephototools`) for creating, extracting, and repairing these files. The core operation involves appending an MP4 video to a JPEG image and managing the associated XMP metadata (Google's GCamera and Container namespaces). It also supports generating long exposure photos from video frames and copying metadata between images. The architecture is a well-structured monolith written in Vala and built with Meson. The core logic resides in a shared library, with CLI and GUI frontends linking against it. Video processing is handled by a clean strategy pattern, defaulting to an in-process GStreamer pipeline with an FFmpeg subprocess fallback. The build system is highly sophisticated, supporting Linux (Flatpak, Arch), Windows (MSYS2), macOS (Homebrew), and Android (experimental, via pixiewood). The codebase demonstrates strong software craftsmanship. It features clean abstractions (abstract base classes `LivePhoto`/`LiveMaker`), meticulous thread safety (GOnce, AtomicInt, AsyncQueue, Mutex), and well-encapsulated utility components. The `PipelineWatch` class for GStreamer error handling and the `Reporter` class for CLI output are particularly well-crafted and reusable. The primary weakness is the absence of a formal unit test suite, which prevents a higher quality score.
ZXing (Zebra Crossing) is a mature, multi-format barcode image processing library written in Java. It provides both decoding and encoding capabilities for over 15 1D and 2D symbologies, including QR Code, Data Matrix, Aztec, PDF417, UPC/EAN, Code 128, and many more. The core library is platform-independent, with additional modules for Android (Barcode Scanner app), Java SE (command-line tools), and web applications (a decode servlet and a GWT-based generator). The architecture follows a clean Reader/Writer interface pattern, with format-specific implementations decoupled from common infrastructure like Reed-Solomon error correction, binarization, and perspective transformation. The library is in maintenance mode: no new features are planned, but bug fixes and minor enhancements from the community are accepted. The Android app is deprecated and does not work on Android 14. Despite its age, the codebase remains a reference implementation for barcode standards and is widely ported to other languages.
Seal is an Android application that serves as a graphical frontend for yt-dlp, enabling users to download videos and audio from a wide range of websites. Built with Kotlin and Jetpack Compose, it features a Material Design 3 interface with dynamic color theming. The app manages download tasks through a state machine, supports playlists, custom command templates, cookies, SponsorBlock integration, and extensive format selection. It relies on yt-dlp (via youtubedl-android), FFmpeg, and aria2c as external engines, and uses Room for local database storage, MMKV for preferences, and Koin for dependency injection. The architecture is a single-activity Compose Navigation app with a foreground download service. While the codebase is well-organized and actively maintained, it exhibits some technical drift (e.g., deprecated Accompanist WebView, minimal test coverage) and contains a few monolithic modules. Notable reusable components include a standalone color science library implementing CAM16/HCT, a backup/restore utility for database objects, and a custom motion system for Material Shared Axis transitions.
PhotoEditor is an Android library (published on Maven Central) that provides a comprehensive image editing SDK. It allows users to draw on images with customizable brushes and shapes (line, oval, rectangle, arrow), apply filter effects via Android's deprecated MediaEffect API, add and edit text with rich styling (color, font, shadow, border), insert emoji and stickers, and perform pinch-to-scale/rotate gestures on added elements. The library is built around a `PhotoEditorView` custom RelativeLayout that composes an ImageView, a DrawingView (custom canvas for brush/shape rendering), and an ImageFilterView (GLSurfaceView for filters). The architecture employs several design patterns: Builder (PhotoEditor, ShapeBuilder, TextStyleBuilder, SaveSettings), Composite (Graphic interface with Text, Sticker, Emoji implementations), Strategy (Shape interface with concrete shapes), and Listener (OnPhotoEditorListener, BrushViewChangeListener). The sample app demonstrates all features. The library has a robust undo/redo system managed by GraphicManager and PhotoEditorViewState. While the core functionality is solid, the filter implementation relies on deprecated Android APIs (android.media.effect), which is a known limitation and source of issues. The codebase is well-structured with unit and instrumentation tests, CI/CD pipelines, and proper Kotlin coroutines for async saving.
This repository provides flutter-webrtc, a Flutter plugin that wraps native WebRTC SDKs (Android, iOS, maccOS, Windowws, Linux, embedded Linux, and Web) to enable real-time audio/video communication, screen shaning, data channels, and end-to-end encryption. The architecture follows a common Dart interface with platform-specific implementations using method channels, event channels, and texture registries. Key entry points include the Dart factory classes (RTCFactoryNative/Web) and native plugin handlers (FlutterWebRTCPlugin on each platform). The plugin exposes a comprehensive WebRTC API including getUseMedia, peer connections, tranceivers, simulcast, stats, and E2EE via frame cryptors. It is actively maintained with regular commits and issue triage, but exhibits code duplication across platforms and some fragile patterns (reflection, monoilithic method handlers).
Vanadium is a hardened fork of Chromium for Android, developed by GrapheneOS. It serves as both the default browser and the system WebView provider on GrapheneOS devices. The repository contains a large set of patches (over 300) applied to the Chromium source tree, modifying default settings to enhance privacy and security: disabling telemetry, network prediction, third-party cookies, safe browsing, sign-in, media router, background sync, sensors, and many other features. It enables strict security policies like HTTPS-only mode, strict site isolation, partitioned connections, and Do Not Track. The build system uses GN with custom extension files to inject downstream code into Chromium targets. A separate 'config APK' delivers runtime feature flags and ad-blocking filter lists. The repository also includes patches for GrapheneOS-specific OS integration (custom permissions, connectivity checks, seccomp-bpf sandboxing). The codebase is actively maintained with frequent rebases to upstream Chromium, but the high patch count introduces significant merge conflict risk.