drozer is a comprehensive Android security testing framework that operates as a Python CLI application with a Twisted-based server and an on-device agent. Its primary function is to assess the security posture of Android applications and devices by enumerating components (activities, services, content providers, broadcast receivers), scanning for vulnerabilities (SQL injection, path traversal, world-writable files), and delivering exploitation payloads (reverse shells, privilege escalation). The architecture follows a client-server model: the drozer console connects to a remote server (port 31415) that communicates with an agent running on the Android device via a custom protocol defined by Protocol Buffers. The agent exposes a remote Java reflection API (pysolar) that allows the console to invoke arbitrary methods, instantiate objects, and interact with the Android runtime.
This repository contains an Android application that uses the Shizuku framework to gain privileged access to system services for modifying carrier configuration. The app enables VoLTE and other IMS-related settings by overriding carrier config parameters for all active subscriptions. It consists of two main components: a ShizukuProvider that handles binder communication with the Shizuku service, and a PrivilegedProcess (Instrumentation subclass) that runs in a privileged context to grant permissions and apply carrier config overrides. The application targets Android SDK 34-37 and relies on the Shizuku and HiddenApiBypass libraries for system access and hidden API bypass.
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.
This repository provides a comprehensive toolkit for Android ROM modification, featuring a menu-driven interface for extracting, modifying, and repacking Android system images. The architecture is modular and script-based, with main entry points in start.sh (and language variants) that dispatch to specialized scripts for operations like image extraction, modification, and flashable package creation. Key workflows involve setting up isolated workspaces, processing images via filesystem-specific tools (ext4, f2fs, erofs), applying modifications (debloating, feature additions), and generating flashable ZIP or Odin TAR packages. The toolkit integrates numerous open-source utilities for low-level operations, including boot image manipulation (AVB, DTBO), filesystem utilities, and APK optimization tools. While functional and well-organized for its niche purpose, the reliance on external binaries and AOSP-copied components introduces maintenance considerations.
The devoxx4kids/materials repository is a collection of educational resources designed for conducting workshops that teach children and teenagers about programming, robotics, electronics, and game development. It includes a wide variety of workshop materials such as slide presentations (in PowerPoint, PDF, and Key formats), lesson plans, code examples, and hands-on activity guides. The workshops cover topics ranging from basic programming with Scratch and Arduino to more advanced subjects like Minecraft modding, Android app development, and Internet of Things projects using platforms like Tinkerforge and Raspberry Pi. While the repository does not represent a single software application, it contains numerous runnable code examples that are used as teaching aids during the workshops. These include complete Android projects, Arduino sketches, Minecraft mods (using Forge), and Scratch projects. The materials are organized by workshop topic and often include translations in multiple languages (English, Dutch, French, German, etc.), reflecting the international nature of the Devoxx4Kids initiative. One notable reusable component is the Android project structure found in the workshops/Android directory, which demonstrates a well-organized Gradle-based build setup with proper source organization, resource management, and unit testing. This component can serve as a template for creating new Android applications. The repository also shows reuse of the Reveal.js HTML presentation framework across multiple workshops (such as Calliope and Flappybird), indicating a pattern for creating consistent, web-based slide decks. The repository appears to be actively maintained, with a recent commit (as of the provided data) and ongoing community interest (as evidenced by stars and forks). Technical dependencies appear to be up to date, and the materials are generally functional and suitable for their educational purpose, though they prioritize simplicity and clarity over advanced software engineering practices.
This repository provides an Android ad-blocking Magisk module (named '去广告' / 'Remove Advertise') that blocks ads at the system level using hosts file redirection, iptables firewall rules, file locking (chattr), and app component disabling (pm). It includes a comprehensive, community-curated blocklist in both hosts file format (all, reward) and Adblock Plus format (adb.txt), targeting Chinese mobile apps and ad networks. The repo also hosts a GitHub Pages website (index.html) for distribution, donation, and version history (over 200 releases). While primarily an application (Magisk module), it has a strong data component in the form of curated blocklists, making it a hybrid project. The module is distributed as flashable ZIP archives in the module/ directory, with an update.json for Magisk's auto-update mechanism. The codebase is functional and well-used (1014 stars) but shows signs of maintenance burden (large version list, incomplete English documentation, history-cleanup workflow that destroys git history).
This repository is a comprehensive Flutter learning project that simulates an e-commerce management system (merchant order, goods, statistics, shop settings, account/withdrawal). It showcases a wide array of Flutter techniques: MVP architecture with a base presenter pattern, provider state management, custom animations (Lottie, ripple, scratch card), custom chart widgets (bezier and pie charts), complex scrolling (NestedScrollView, custom scroll view), dark mode, localization (English/Chinese), QR code scanning, image picking, AMap integration, and more. The application contains multiple modules connected via fluro routing, with Dio for networking (targeting a mock GitHub API). While the codebase demonstrates many patterns and includes a significant test suite (unit, integration, accessibility), it is primarily a personal learning project and contains several signs of incomplete migration, mock-only behaviors, workarounds, and copied/vendored code. As such, it serves as a rich educational reference for Flutter development but is not production-ready without refinement.
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.
EhViewer_CN_SXJ is an Android application for browsing, searching, and downloading content from E-Hentai (a manga/doujinshi platform). It provides a full-featured gallery viewer with offline download management, image caching, and archive extraction. The app integrates native C/C++ libraries (libjpeg-turbo, libpng, libwebp, giflib) via JNI for high-performance image decoding, and uses a custom OpenGL-based rendering framework (GLView) for smooth gallery navigation. The architecture is a monolith with a scene-based UI navigation system, a SQLite-backed persistence layer (greenDAO), and a custom HTTP client built on OkHttp with proxy and cookie management. The codebase is a mix of Java and Kotlin, with extensive native code for image processing and SIMD optimizations (SSE, NEON, MIPS). While the app is functional and actively maintained, it exhibits significant technical debt: tight coupling to E-Hentai's HTML structure, deprecated Android API usage, a forked Android-like environment, and heavy vendored native libraries that require ongoing security updates. The project demonstrates some reusable patterns (Conaco caching, UniFile abstraction, custom collections) but overall is a domain-specific application with limited generalizability.
MiCode/Xiaomi_Kernel_OpenSource is Xiaomi's official GPL compliance release mechanism for Linux kernel sources powering its Android devices. The default branch (named 'README') contains no application or library code whatsoever -- only a single Markdown file that serves as a structured index mapping ~200 device codenames (e.g., dada-v-oss for Xiaomi 15, alioth-r-oss for Mi 10S) to git branches. Each branch holds the actual Linux kernel source tree for a specific device/Android-version combination, based on Qualcomm CodeAurora (LA.UM/LA.VENDOR) or MediaTek (alps-*) vendor base tags identified in the table. There are no APIs, executables, build scripts, or tests in this branch; the repository's real product is the branch-per-device collection of GPL-required kernel sources. Architecturally this is a source distribution index rather than software. Its value is as reference data: developers building custom ROMs, security researchers auditing device kernels, and compliance tooling all use the README to locate the correct branch for a given device. The catalog is actively maintained -- entries for Android W devices (Xiaomi 17 series, Redmi K90, Xiaomi Pad 8) and a recent commit dated 2026-10-12 indicate ongoing releases -- and the table format is consistent enough to be machine-parsed. However, it exhibits manual-maintenance defects: several links point to differently-named branches (diting-s-oss -> bsp-diting-s-oss, corot-s-oss -> corot-t-oss, goku-u-oss -> goku-u-oss-test), some rows contain stray whitespace, and a few devices appear with overlapping/duplicated entries. The repository is not reusable as a software component, but it is a uniquely comprehensive authoritative mapping of Xiaomi devices to their kernel sources.
Yasea is an Android live-streaming library and demo application that captures camera video and microphone audio, applies real-time GPU image filters, hardware-encodes to H.264/AAC via MediaCodec, muxes into FLV, and publishes over RTMP to servers such as SRS. The main entry point is SrsPublisher, which orchestrates SrsCameraView (an OpenGL ES preview surface), SrsEncoder (MediaCodec lifecycle and format negotiation), SrsFlvMuxer (FLV-over-RTMP publishing), and SrsMp4Muxer (simultaneous MP4 recording). The demo app (MainActivity) provides a working UI for URL entry, publish/pause, camera switching, recording, and filter selection. Architecturally, the repo is a Gradle project with two modules: a reusable Android library (library/) and a demo app (app/). The library is a monolith that bundles large vendored third-party codebases as source: Google's libyuv (native YUV/RGB conversion and scaling), mp4parser (ISO BMFF/MP4 parsing and authoring), simple-rtmp (RTMP client protocol), and MagicCamera (40+ GPU image filters with GLSL shaders). The repo's own code is the net.ossrs.yasea package, which integrates these pieces: camera frames flow through the GLSurfaceView filter chain as RGBA, are converted to I420/NV12 by the libenc JNI bridge (libenc.cc wrapping libyuv), encoded by MediaCodec, and muxed to FLV/MP4. Audio is captured via AudioRecord and encoded to AAC. Despite a recent commit, the codebase is frozen in the 2017-2020 Android era: compileSdk/targetSdk 26, Android support library 26.1.0, the deprecated Camera API, Gradle 6.5 with AGP 4.1.1, and a mips ABI that modern NDKs no longer support. The native build is commented out in library/build.gradle, and 285 open issues remain. Technical drift is high. This is purely an application/library repo - no data pipelines, notebooks, or research components.
This is the OpenIM SDK Core, a cross-platform instant messaging client SDK written in Go. It provides the core messaging functionality—send/receive messages, manage conversations, groups, friends, user profiles, and file uploads—for the OpenIM ecosystem. The SDK communicates with an OpenIM server via HTTP REST and WebSocket long connections, and persists data locally using SQLite (native) or IndexedDB (WebAssembly). It features robust incremental synchronization, a callback-driven architecture for event handling, and extensive support for multiple platforms (iOS, Android, Windows, macOS, Linux, Web). The codebase demonstrates solid engineering practices with generic sync engines, caching utilities, and a comprehensive integration test suite. However, it also contains notable code duplication (dual native/WASM storage implementations), incomplete WASM stubs, some panic-based error handling, and alpha-stage dependencies, which prevent it from being exceptional. Overall, it is a functional, actively maintained SDK with reusable patterns for incremental sync and WebSocket connection management.
Daijin is a container management tool designed for Android devices running Termux. It provides a menu-driven interface to create, run, remove, and manage Linux containers using either the ruri backend (a lightweight container implementation) or proot (a chroot alternative). The application orchestrates container lifecycle operations by integrating with submodules rurima (for running Docker/LXC images without Docker/LXC) and rootfstool (for obtaining container rootfs from mirrors). Key functionalities include downloading container images, setting up container environments with proper permissions and networking, managing container configurations, and providing launch mechanisms. The architecture is monolithic with modular shell scripts handling specific operations, all built as a Debian package for Termux deployment.
This repository is a multi-module Android application that functions as a cheat client for Minecraft Bedrock Edition. It intercepts and modifies network packets between the client and server using a custom relay/proxy (Lunaris) and a comprehensive implementation of the Bedrock protocol (CloudburstMC-derived). The app provides a graphical overlay (Pixie with ImGui) for toggling cheat modules such as flight, speed, killaura, ESP, and more. It also includes Microsoft/Xbox authentication, Discord Rich Presence, and an update check mechanism with native signature verification. Architecture: The project is organized into several Gradle modules: `app` (main Android app with Compose UI and cheat modules), `Protocol/bedrock-codec` (versioned Bedrock packet serializers), `Protocol/bedrock-connection` (Netty-based session management), `Network/transport-raknet` (custom RakNet UDP transport), `Lunaris` (relay/proxy for packet interception), `Pixie` (native C++ overlay with ImGui and Dobby hooking), `minecraft-msftauth` (Microsoft authentication), `lunarisrpc` (Discord RPC), and `animatedux` (Compose UI components). The app uses a packet interception pattern where cheat modules (subclasses of `Element`) override `beforePacketBound` to modify or cancel packets before they are sent to the server. Key entry points: `app` module's `MainActivity` or `LaunchActivity` (Android entry), `Pixie`'s `MuffinService` (overlay service), `Lunaris`'s `LuminaRelaySession` (relay logic), and the protocol codec builders (e.g., `Bedrock_v898`). Data flows: The app connects to a Bedrock server via RakNet, the relay intercepts packets, cheat modules modify them, and the modified packets are forwarded. The protocol library handles serialization/deserialization for dozens of protocol versions. External dependencies: Netty (network), OkHttp (HTTP), Firebase (analytics/crashlytics), Gson (JSON), fastutil (collections), Lombok (Java boilerplate), AndroidX Compose (UI), ImGui (native overlay), Dobby (native hooking), and various Android SDK components.
WebViewTvLive is an Android TV live streaming application that uses the Tencent X5 WebView to display official TV channel web pages. It loads channel playlists from remote JSON sources, caches them locally, and provides a TV-optimized UI with remote control and touch input support. The app employs a per-site adapter pattern (WebpageAdapter) to inject JavaScript and trigger fullscreen playback for different streaming websites (e.g., CCTV, YouTube, MGTV). It features a channel bar, waiting indicator, settings for aspect ratio and source selection, and automatic playlist updates. The codebase is well-structured with separation of playlist management, settings, and UI, but the project is officially paused as open source, with the last released version being 1.6. Dependencies are reasonably up-to-date, though some deprecated Android APIs are used.
This repository contains a fully functional Android application named 'Bluetooth LE Spam' that transmits crafted Bluetooth Low Energy advertisements to spoof a wide range of devices (Apple Continuity, Microsoft Swift Pair, Google Fast Pair, Samsung Easy Setup, Lovespouse) on nearby phones and tablets, triggering unwanted pop-ups and notifications. It also includes a spam detector that identifies BLE spam originating from Flipper Zeros and similar tools, running as a foreground service even on the lock screen. The application is built with Kotlin, Jetpack Compose, Material 3, Room database for persistence, and uses both legacy and modern (BLE 5) advertising modes. The codebase is well-structured around an interface-based advertisement set generator pattern and a queue handler for cycling through attacks, but it is explicitly unmaintained by the author and many exploits are patched on modern OS versions, limiting practical impact. The architecture is a standard Android single-activity app with multiple fragments and foreground services; the theme system (dynamic color, custom nav bar, status badges) demonstrates reasonable front-end craftsmanship.
LibreraReader is a full-featured, multi-format e-book reader for Android (with an experimental iOS/desktop port via Kotlin Multiplatform). It supports PDF, EPUB, MOBI, DjVu, FB2, CBR/CBZ, DOC/DOCX, ODT, RTF, and many other formats through a combination of native C/C++ libraries (MuPDF, DjVuLibre, libmobi, libantiword, libwebp, liblame) and Java-based document translators (ODF/SVM/WMF to HTML/SVG). The app provides a rich reading experience with customizable themes, text-to-speech, OPDS catalog browsing, cloud sync (Google Drive, Dropbox), annotations, bookmarks, and a smart reflow feature for scanned documents. The codebase is large and monolithic, with significant third-party code vendored into the source tree. Development has been frozen (as noted in the README), so the project is in a maintenance-only state. Despite its age and complexity, it contains several well-crafted, reusable utility libraries (e.g., LWXML streaming XML framework, SVM-to-SVG translator, and general-purpose Android utilities) that could be extracted for other projects.
This is the Qualcomm Innovators Development Kit (QIDK), a collection of Android sample applications and tools demonstrating on-device AI inference using the Qualcomm Neural Processing SDK (SNPE) and Qualcomm Neural Network (QNN) runtime. The repository covers computer vision (object detection, pose estimation, super-resolution, image enhancement), NLP (sentiment analysis, question answering, automatic speech recognition), and generative AI (LLM chat, speech-to-image, ASR-LLM-TTS pipeline). Each solution is a standalone Android app with native C++ JNI code that integrates the SNPE/QNN SDK for accelerated inference on Snapdragon platforms. The repository also includes tools like `pysnpe_utils` (Python library for model conversion and execution), `snpe-helper` (Python wrapper for SNPE runtime), and low-level Hexagon compute examples (QHCI/HVX). While the codebase is functional and covers a wide range of use cases, it suffers from significant code duplication across solutions, hardcoded paths, and version coupling to specific SDK releases. The architecture is a collection of loosely coupled sample apps rather than a unified framework, limiting cross-project reuse. The commit history shows ongoing maintenance, but the last commit date appears anomalous (2026), and several files reference future copyright years, suggesting pre-release content.
This repository provides a kernel module for tracing user-space functions using uprobe, along with a user-space tool to clear uprobes. The kernel module hooks into the mincore system call to set up tracing parameters and function probes. It uses a red-black tree implementation to store function information. The module is designed for Android and has been tested on kernel versions 5.10 and 5.15, with claimed support for 6.x kernels. The user-space tool is a simple executable that invokes the mincore system call to clear all set uprobes.
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.