scrcpy is a high-performance desktop application that mirrors and controls Android devices over USB or TCP/IP. The client is a native C application using SDL3 for rendering and input, FFmpeg for media decoding, and libusb for USB-OTG mode. The server is a Java service running on the Android device that captures screen and audio via MediaCodec and hidden Android APIs, streaming them over an ADB tunnel. The system supports multiple input modes (SDK injection, UHID, AOA HID), video/audio recording, V4L2 loopback output, and clipboard synchronization. Architecture is client-server with a well-defined protocol, trait-based pipeline for frame/packet processing, and extensive cross-platform support (Linux, Windows, macOS).
The AdvancedSharpAdbClient is a .NET library that provides a managed implementation of the Android Debug Bridge (ADB) protocol, enabling developers to interact with Android devices without relying on the external `adb.exe` executable. It offers a comprehensive suite of features including device connection management, shell command execution, application installation and uninstallation, file transfer via ADB sync service, screen capture, and device state monitoring. The library is designed with a strong emphasis on testability and loose coupling, utilizing interfaces and a factory pattern for dependency injection. Architecturally, the library is structured as a set of cohesive, loosely coupled components. Core communication is handled by `AdbSocket` (low-level TCP) and higher-level operations are exposed through `AdbClient`, `DeviceClient`, `PackageManager`, and `SyncService`. The library makes extensive use of interfaces to allow for easy mocking in unit tests and provides asynchronous counterparts for most operations to support non-blocking programming models. It targets a wide range of .NET frameworks (from .NET Framework 3.5 to .NET 10+) using conditional compilation and polyfills to maintain compatibility. The library demonstrates solid engineering practices through its use of the factory pattern for object creation, extension methods to enhance interface usability, and careful handling of binary data structures for statistics and framebuffer headers. Its comprehensive test suite, which includes mock implementations for various components, ensures reliability and facilitates safe evolution. While the broad target range introduces some complexity via conditional compilation symbols, the code remains well-organized and maintainable, reflecting a commitment to serving a diverse set of .NET applications requiring Android device interaction.
App Manager is a production Android package-management application rather than a data or research codebase. The source code confirms a deep, privileged management tool: it inspects installed applications, edits components/permissions/app ops, freezes and uninstalls packages, backs up and restores app data with multiple encryption schemes (AES, RSA/ECC, OpenPGP), applies profiles and batch operations, manages root/ADB execution, performs APK/tracker/VirusTotal analysis, and bundles ancillary tools such as a file manager, code editor, logcat viewer, PDF/audio viewers, and terminal. The hybrid-looking data features—VirusTotal scan caching, tracker signature datasets, usage statistics, debloat lists—are product features, not the repository's primary purpose.
This repository provides a cross-platform desktop application (GUI and CLI) for debloating Android devices by uninstalling or disabling unwanted system packages. It is built in Rust using the Iced GUI framework for the interface and a shared core library (`uad-core`) that abstracts ADB communication, package list management, backup/restore, and self-update logic. The tool leverages a community-maintained package classification database (embedded JSON) that categorizes packages by vendor (AOSP, Google, OEM, etc.) and removal safety (Recommended, Advanced, Expert, Unsafe). The architecture is modular: `uad-core` handles all ADB operations and data logic, `uad-cli` provides a command-line interface with subcommands for device management, package list filtering, and actions, and `uad-gui` offers a modern graphical interface with search, filter, bulk selection, and settings for cross-user and fallback modes. The codebase is well-organized with clear separation of concerns, custom theming, and a generic modal overlay widget. It demonstrates solid engineering practices for a desktop tool, though some components (like the embedded large JSON and complex fallback logic) introduce maintenance complexity.
This is an awesome list curating applications, libraries, and tools that leverage Shizuku, an Android API for providing elevated privileges (ADB) to normal apps without root. The repository itself is not a software application but a meticulously maintained directory with automated tooling including link checking, formatting linting, and translation synchronization scripts. The Python scripts (check_links.py, lint.py, sync_translations.py) exhibit non-obvious skill in automating awesome list maintenance and are reusable for similar curation projects. The list is comprehensive, well-organized, and actively maintained with CI pipelines and regular updates.
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.
AzurLaneAutoScript (ALAS) is a Python-based game automation bot for the mobile game Azur Lane. It uses computer vision (OpenCV, template matching, OCR via cnocr/mxnet) and Android Debug Bridge (ADB) to control an emulator, automating nearly all gameplay loops: campaign sorties, daily missions, research, dormitory, guild operations, Operation Siren, and event-specific maps. The architecture is modular, with a core framework providing device abstraction (module/device), image recognition (module/ocr, module/map_detection), configuration management (module/config), and a web UI (module/webui) built on PyWebIO with an Electron wrapper. Campaign logic is organized into hundreds of per-event map scripts under campaign/, each defining map grids, enemy spawns, and battle strategies via a consistent CampaignBase subclass pattern. The system runs as a daemon, continuously executing scheduled tasks with configurable priorities and notifications (onepush, Discord). External dependencies include uiautomator2, adbutils, OpenCV, cnocr, mxnet, pywebio, and zerorpc, with pinned versions targeting Python 3.7. The codebase is actively maintained with frequent updates for new game events, but suffers from significant duplication across campaign files and reliance on outdated library versions.
This repository provides the Python library `uiautomator2` for Android UI automation. It allows scripts to control Android devices by sending HTTP/JSON-RPC requests to an on-device server (either a Java-based UiAutomator2 jar or the older atx-agent). The core functionality includes element selection via selectors and XPath, gesture simulation (click, swipe, drag), text input via an IME, screenshot capture, UI hierarchy dumps, and app management. It also ships a CLI tool (`u2cli`) with subcommands for device inspection, app operations, and an agent server that exposes a persistent API for LLM/agent-based interactions. The architecture follows a client-server pattern where the Python client communicates over ADB-forwarded ports. The repository includes extensions for HTML reports, performance monitoring, and device info lookups, as well as archived modules for OCR and image recognition. It is widely used for automated testing of Android applications.
AndroidDrive is a Windows desktop application that mounts Android smartphone internal storage and SD cards as drive letters using the Dokan user-mode filesystem driver and ADB (Android Debug Bridge). It is built with Qt6 (C++20) and CMake, providing a system tray interface, device list window, and per-drive settings (drive letter, auto-mount, language, hide dot files). The application communicates with Android devices via ADB commands, caches remote files locally for read/write operations, and pushes changes back. It supports 10 languages via Qt translations and includes an update checker that queries GitHub releases. The architecture is a single-process Qt application with a Dokan callback implementation for filesystem operations. Key entry points are main.cpp (application startup), androiddrive.cpp (core mount logic), and dokanoperations.cpp (filesystem callbacks). External dependencies include Qt6, Dokan library (v2.3.1), and ADB binaries fetched from a third-party GitHub repo. The codebase is well-structured but has some hardcoded paths and is Windows-only.
Stellar is a Shizuku-fork Android application that provides a privileged service framework enabling apps to use system-level APIs without root. The repository contains two main modules: a manager app with Jetpack Compose UI (including home dashboard, app permission management, terminal command execution, settings, and a startup wizard) and a server process that runs as a system service via app_process, managing Binder IPC, permissions, remote process creation, and Shizuku API compatibility. The manager app uses Room for persistent configuration and logs, while the server communicates with the manager and client apps through Binder and a ContentProvider bridge. The project demonstrates deep integration with Android internals (hidden APIs, ProcessObserver, UidObserver) and includes native C++ code for ADB wireless pairing via mDNS and TLS, as well as privilege drop and cgroup management. While the code is well-organized and modular in parts, it is tightly coupled to Android platform specifics and lacks automated tests, making it primarily useful as a reference for building similar privilege-escalation frameworks or for users wanting to manage Stellar on their devices.
ADBKeyBoard is an Android virtual keyboard (InputMethodService) designed to receive text input and key events via system broadcast intents sent from ADB. It overcomes the limitation of `adb shell input text` which cannot handle Unicode characters. The app listens for intents like ADB_INPUT_TEXT, ADB_INPUT_B64 (base64-encoded text), ADB_INPUT_CODE (keyevent), ADB_EDITOR_CODE (editor actions), ADB_INPUT_CHARS (Unicode codepoints), ADB_CLEAR_TEXT, and direct IME actions (SEARCH, GO, DONE, NEXT, SEND). The single Java source file (AdbIME.java) implements the entire logic: registering a BroadcastReceiver, parsing intent extras, and using InputConnection to inject text or keys into the current input field. The code is straightforward and minimal, with no external libraries beyond the Android SDK. It has been widely used for device automation and testing (nearly 2000 stars). However, the codebase is monolithic, lacks tests, and shows signs of gradual maintenance (e.g., Android 13 compatibility fixes, but still targets older API levels). It is not designed for reuse outside of Android, but the broadcast-receiver-command pattern is clean and could serve as a reference for similar automation keyboards.