This is an Android application named 'Parcel - Pickup Code' that automatically parses incoming SMS text messages to extract parcel pickup codes and delivery addresses. The app displays the extracted information on home screen widgets (available in multiple sizes) and provides a rich UI built with Jetpack Compose. Core features include: automatic SMS parsing with configurable custom regex rules, support for monitoring third‑party app notifications (WeChat, Pinduoduo, TikTok, Xiaohongshu) to capture pickup codes, address grouping with labels, senior mode with enlarged text, dark theme, and persistent data storage via SharedPreferences. The architecture follows standard Android patterns: a main activity orchestrates permissions and data refresh, a ViewModel manages state, a dedicated SMS parser processes messages, and background services (NotificationListenerService, periodic health checks) keep widgets updated. The app is deliberately offline and does not collect personal data.
Material Files is a sophisticated, open-source Android file manager built with Kotlin and Material Design principles. Its core architecture is a custom implementation of the Java NIO2 file system API (`java.nio.file.spi.FileSystemProvider`), providing a unified abstraction over multiple backends: the local Linux filesystem (accessed via JNI syscalls), Android's proprietary Documents/Content providers, and remote network protocols including SMB, SFTP, FTP, and WebDAV. The UI is constructed from Android Fragments, RecyclerView adapters, and custom Material Design widgets, orchestrated by a ViewModel/LiveData pattern for reactive state management. The application goes far beyond basic file browsing. It features a comprehensive background file job service for copy, move, delete, and archive operations with progress tracking and conflict resolution. It includes a built-in FTP server, an image viewer with EXIF support, a text editor, and deep file property inspection (APK metadata, audio/video tags, checksums, POSIX permissions, and SELinux context). Root access is achieved through a separate process communicated via AIDL (Android Interface Definition Language), demonstrating a sophisticated IPC architecture for privilege escalation. The codebase is actively maintained by a single developer, with recent commits and a clear version history. However, it suffers from high technical drift due to its heavy reliance on Android's internal, undocumented, and frequently changing APIs (e.g., `android.system`, `android.os.storage`). The extensive `compat` package is a testament to the constant battle against platform evolution. This makes the project fragile and high-risk for long-term maintenance without dedicated effort. Despite its overall complexity, the repository contains several genuinely reusable, high-craftsmanship components. Standouts include the `ByteString`/`ByteStringPath` classes for handling non-UTF-8 filesystem paths, a generic `ListDiffer` algorithm, a robust `Stateful`/`DataState` state machine pattern, and clean implementations of throttling/debouncing. These components are self-contained and could be extracted for use in other Kotlin or Java projects. The overall quality score is 7.5, reflecting strong engineering and feature depth, balanced against significant platform-specific technical debt.
Dependency Guard is a Gradle plugin that monitors and protects against unintentional dependency changes in JVM-based projects. It creates baseline files of project dependencies for specified configurations and compares current dependencies against these baselines during build execution. When unintended changes are detected, it fails the build and provides a clear diff of what changed, allowing developers to either re-baseline for intentional changes or investigate problematic dependency drift. The plugin supports both simple list format and hierarchical tree format for dependency reporting, with the list format being recommended for CI usage due to less noise. It integrates with Gradle's lifecycle by automatically attaching to the 'check' task and provides clear commands for creating and updating baselines.
Nearby Glasses is a cross-platform mobile application (native Android in Kotlin and iOS in Swift/SwiftUI) that continuously scans Bluetooth Low Energy (BLE) advertisements to alert users when smart glasses from known manufacturers (Meta, EssilorLuxottica, Snap, Zhuhai Jieli) are nearby. Detection is based on immutable BLE company IDs and device-name substrings, with configurable RSSI threshold and notification cooldown. The Android app runs a foreground service for background scanning; the iOS app currently scans only in the foreground and offers a 'Canary Mode' visual indicator instead of system notifications. The app is privacy-focused: no telemetry, no ads, local-only logs with user-initiated export.
This repository contains the Amaze File Utilities Android application, an open-source file management utility suite with built-in media players. The app provides comprehensive file browsing, storage analysis (duplicate, large, hidden, junk files), image/video/audio playback, image editing, document viewing (PDF, EPUB, DOCX), and peer-to-peer file transfer via Wi-Fi Direct. It also includes a cloud streaming server for Chromecast support. The architecture follows the standard Android MVVM pattern with Jetpack components (ViewModel, LiveData, Room, Navigation), and uses a foreground service for audio playback. The codebase is primarily Kotlin with some legacy Java, and is built with two product flavors: one for the Play Store (with billing and ML Kit) and one for F-Droid (without those features). The app demonstrates solid engineering with reusable abstractions like `AbstractMediaFilesAdapter`, `CloudStreamer`, and `FixedSizePriorityQueue`, though the central `FilesViewModel` is overly large (2000+ lines) and some deprecated Android APIs remain in use. The project is actively maintained with recent commits and zero Dependabot alerts.
Repository is a production Android application for Mixin Network, combining a cryptocurrency wallet with a messenger. It integrates with Mixin API (api.mixin.one) and Blaze messaging, supports transfers, swaps, web3 trades, perps, fiat money, and market analytics. The app is built with Kotlin, uses MVVM with ViewModels and Flows, Room for persistence, and a mix of Jetpack Compose and legacy View-based UI. A separate query-codegen Gradle module generates type-safe query code, and release automation includes Fastlane, Docker build box, and APK signature verification.
This is Google's official Java samples monorepo for Google Cloud Platform. It contains thousands of standalone runnable snippets and small demo applications organized by GCP product (App Engine, Cloud Functions, Cloud Run, BigQuery, Spanner, Bigtable, Vertex AI, IAM, KMS, Secret Manager, and more). The primary architectural pattern is a multi-module collection of independent Maven/Gradle projects, each containing a `main()`-driven sample class, region-tag comments for documentation embedding, and JUnit integration tests that usually validate printed output against live GCP services. It is not a cohesive production application, but rather a reference corpus for GCP Java client libraries, with occasional fuller examples such as the Bigtable gRPC proxy, Apache Beam pipelines, and Spring Boot Cloud Run services. Functionally, most samples follow a simple data flow: construct a service client, build a request, call one or a few API methods, then print the result. HTTP entry points exist in the form of servlets, Cloud Functions handlers, and Spring/Spark controllers in the App Engine, Cloud Functions, and Cloud Run directories. A smaller number of modules implement data workflows using Apache Beam, BigQuery Data Transfer, and Vertex AI. The repository relies heavily on generated Google Cloud Java client libraries, GCP service endpoints, and common supporting libraries such as HikariCP, Spring Boot, GSON, and Google Truth in tests. The repository is actively maintained, with recent commits and CI coverage via Kokoro, but technical drift is medium. A substantial portion of the code is legacy App Engine Java 8 samples, deprecated services such as Cloud IoT, near-duplicate modules across Java 8/11/17/21/25 runtime variants, and many samples contain `TODO(developer)` placeholders or hardcoded resource IDs. Ignored or flaky integration tests and mixed API versions (e.g., v1 vs v2 Security Command Center, v4 vs v4beta1 jobs) reinforce that this is a sample reference rather than a hardened codebase. Its value is breadth and officiality, not architectural cohesion.
Automation Gateway is a reactive, configuration-driven bridge for industrial protocols (OPC UA, MQTT, PLC4X) that routes real-time process data to multiple time-series databases (InfluxDB, IoTDB, OpenSearch, Cassandra, PostgreSQL, etc.) and exposes it via GraphQL, MQTT, and OPC UA servers. The system runs as a single JVM or GraalVM native binary, orchestrated through YAML configuration files that define driver instances, logger sinks, and server endpoints. Its core architecture is built on Vert.x event bus for internal pub/sub messaging, with abstract base classes (DriverBase, LoggerBase) enabling consistent extension for new protocols or data stores. The gateway does not persist data itself; it acts as a real-time router with configurable buffering and queue reliability (memory-mapped disk queue). Key entry points include `App.kt` for the main application and `GraphQLServer.kt` for the administrative API, which supports JWT authentication, health checks, and dynamic component management. External dependencies include Eclipse Milo (OPC UA), HiveMQ MQTT client, PLC4X, Apache IoTDB Thrift, InfluxDB HTTP client, and various database drivers. The codebase is mature (v1.38) with active development, but carries some technical drift in the form of deprecated features still present in source code and a large set of reflection configurations for GraalVM native-image that require careful maintenance.
This repository is the official Spring Boot getting started guide (gs-spring-boot). It provides a minimal web application that demonstrates Spring Boot's auto-configuration, embedded Tomcat, and actuator endpoints. The codebase consists of a single REST controller returning a static greeting string, a Spring Boot application class with a CommandLineRunner that lists all beans, and corresponding unit and integration tests. The complete variant includes Spring Boot Actuator for production-ready features. The repo serves purely as a tutorial scaffold, not a production-grade application. The architecture is a trivial monolith with no external services, database, or complex data flow. All source files are framework boilerplate generated or inspired by Spring Initializr. There are no reusable components or non-obvious patterns. The value lies in its documentation and as a starting point for learning Spring Boot. Despite its simplicity, the repository is actively maintained with up-to-date dependencies (Spring Boot 4.0.x, Kotlin 2.2.x, Gradle 9.3.x) and CI pipelines. It includes both Java and Kotlin implementations, and both Maven and Gradle build systems.
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.
This repository contains a minimal Kotlin application demonstrating how to start a Ktor server using the Netty engine. The Application.kt file configures an embedded server on port 8080 that, upon startup, prints a welcome message to the console. The server does not define any routes, so it does not process HTTP requests. The repository also includes a CC0 1.0 license and a README that curates external Ktor resources (such as books, courses, and projects), though this content is not reflected in the codebase itself.
This is an Android application designed as a learning resource for Kotlin Coroutines. It provides a series of hands-on examples demonstrating common coroutine patterns in Android development, including single/parallel/series network calls with Retrofit, Room database operations, long-running tasks, timeout handling, and error handling strategies (try-catch, CoroutineExceptionHandler, supervisorScope). The architecture follows a simple MVVM pattern with ViewModel, LiveData, and a sealed UiState class. The code is straightforward and intended for educational purposes, with a clear separation of layers (API, database, UI). While it does not exhibit advanced or production-grade architecture, it serves as a practical reference for developers learning coroutines.
This is an Android application named 'Notifications Recovery' that captures, stores, and displays device notifications locally. It runs a NotificationListenerService to intercept all incoming notifications, parses their content (title, text, big text, conversation title, etc.), and persists them to an ObjectBox embedded database. It also detects when notifications are removed and marks them as deleted. The app provides multiple UI screens: a main list of all notifications with search/filter, a chat-style view for messaging apps (using Jetpack Compose), a pie chart for app-wise statistics, and a separate view for deleted notifications. It includes blacklist/whitelist filtering, encrypted ZIP export/import, biometric authentication, screenshot blocking, and three Android home screen widgets (latest, chat, and deleted notifications). The architecture is a monolithic Android app with a service layer, activities using XML layouts, and selected Compose screens. Dependencies include ObjectBox, MPAndroidChart, Zip4j, and AndroidX libraries. The codebase shows active maintenance but suffers from inconsistent version numbers (targeting unreleased SDK 37) and some code quality issues like threading concerns and deprecated API usage.
This repository is a template for creating ReVanced patches. It provides a Gradle multi-module project structure with a patches module and an extensions module, along with example code for a bytecode patch and an Android extension. The template includes CI/CD workflows for building, testing, and releasing patches using semantic release, as well as issue templates and contribution guidelines. The actual patch logic is not implemented (the example patch contains a TODO), making this a scaffolding repository intended to be forked and customized. The codebase is minimal and well-organized, but lacks any non-trivial logic or reusable components beyond the template structure itself.
Geph Android is a production VPN client that wraps a Rust-based circumvention engine (geph5-client) and a web UI (gephgui) inside a native Android application. The architecture is a hybrid of a WebView-hosted UI and a native daemon process: the main activity loads a local HTML/JS UI via WebViewAssetLoader, and a JavaScript bridge (init.js) communicates with Kotlin through @JavascriptInterface to invoke RPC calls over a Unix socket to the daemon. The daemon is spawned as a separate process (libgeph.so) and manages the VPN tunnel via Android's VpnService. The app supports multiple build variants (debug, releaseAPK for sideloading with auto-update, releasePlay for Google Play with Firebase Analytics and Play In-App Review) using a factory pattern to inject platform-specific features. Key data flows include user authentication via broker RPC, VPN start/stop lifecycle, and periodic update checks that download and verify APK signatures. External dependencies include the Rust engine binary, a prebuilt web UI, JNA for native access, and Firebase services for the Play variant.
AutoDing is an Android application that automates DingTalk (a Chinese workplace communication and time-tracking app) clock-in operations. It offers two primary features: (1) scheduled clock-in, where users set a specific time and the app will automatically open DingTalk and trigger the 'quick clock-in' feature, and (2) remote push-based clock-in, where a user can send a command via JPush (a push notification service) from one phone to another, causing the receiving phone to wake up, unlock, and launch DingTalk for clock-in. The app also includes notification monitoring to capture clock-in results, email notifications via QQ mail (using javax.mail), and status reporting (battery level, lock screen state). The architecture is a standard Android monolithic app with multiple services: BaseAccessibilityService and GestureService for UI automation, NotificationMonitorService for listening to DingTalk notifications, and PushCoreService for handling custom push messages. The UI is built with Fragments (ViewPager2) and uses ViewBinding/DataBinding, GreenDAO for local database storage of clock-in history, and Retrofit for network calls to the JPush API and a workday API. The app is written in both Kotlin and Java, with Kotlin being the dominant language for new code. The codebase is functional and demonstrates a working solution for a specific niche problem (automating DingTalk clock-in). However, it is not actively maintained; the author has stopped providing APK builds and recommends users rebuild the app themselves to avoid package name blocking. The code contains several hardcoded credentials (signing keys, JPush appKey/masterSecret) and outdated dependencies (compileSdk 33, AndroidX 1.4.0). While the overall architecture is coherent, the code quality is average with some reusable utility classes but also significant boilerplate and tight coupling to the DingTalk package name.
aTox is an Android client for the Tox peer-to-peer instant messaging protocol. It provides encrypted text messaging, audio/video calls, file transfers, and group chats using the decentralized Tox network. The application follows a clean multi-module architecture: the `domain` module contains pure Kotlin business logic (Tox wrappers, feature managers, validators), the `core` module handles local persistence via Room database (contacts, messages, file transfers, friend requests), and the `atox` module implements the Android UI using Dagger dependency injection, ViewModels, LiveData, and Navigation component. Key entry points include `MainActivity` for handling intents and navigation, `ToxService` for running the Tox loop in a foreground service, and `EventListenerCallbacks` for bridging Tox events to database updates and notifications. External dependencies include the `tox4j` JNI bindings to `c-toxcore`, libsodium for encryption, and opus/libvpx for audio/video codecs. The repository is explicitly unmaintained and carries significant technical debt from its complex Bazel native build system, outdated library versions, and potential security risks inherent in the Tox protocol itself.
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.
This is the Anko library for Android, a Kotlin DSL that provides type-safe builders for UI layouts, SQLite queries, intents, dialogs, async tasks, logging, and other common Android patterns. The repository additionally contains a code generator (using ASM to parse Android SDK classes) that produces extension functions for views, properties, listeners, and services per API level, and an IntelliJ/Android Studio plugin that includes XML-to-Anko conversion, live preview of DSL layouts, and refactoring intentions. The library is officially deprecated (see GOODBYE.md) in favor of Jetpack Compose, Splitties, and Android KTX; the last commit was in 2019. The codebase is well-structured overall, but the generated files are massive and repetitive, and the library has not kept pace with the Android ecosystem (e.g., still uses android.support libraries, GlobalScope for coroutines, and targets SDK versions up to 28). Reusable components include the static commons (Logging, Async, Intents, AlertBuilder), the code generator's class tree and rendering pipeline, and the SQLite query builders.