thehardwarestore.ai

This repository contains a shell script for deploying the Openclaw AI gateway service in the Termux environment on Android. It automates the installation of Node.js dependencies, applies compatibility patches to make Node.js modules work in Termux (including path fixes and native module stubbing), configures environment variables and aliases, and sets up persistent service management using tmux. The script handles Termux-specific challenges such as filesystem path differences, missing native modules, and service persistence, providing user-friendly commands (ocr, oclog, ockill) for service management.

This repository is a comprehensive collection of TensorFlow Lite example applications for on-device machine learning, covering tasks such as image classification, object detection, pose estimation, audio classification, BERT question answering, gesture recognition, and more. It provides complete Android (Kotlin/Java), iOS (Swift), Raspberry Pi, and web implementations, each demonstrating best practices for camera integration, hardware delegate selection, and real-time inference. Additionally, the repository includes the TensorFlow Lite Model Maker library, which offers high-level APIs for training and exporting custom TFLite models from user data, along with research/educational models (DenseNet, pix2pix, NMT). While the codebase shows some duplication across platforms and occasional legacy API usage, it remains a valuable reference for developers building edge ML applications.

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 is an Android application: a specialized game browser for Kantai Collection (KanColle), a Japanese HTML5 browser game. It wraps the game client in a custom WebView with SQLite-backed resource caching (images, audio, fonts with HTTP cache-header awareness), a JavaScript bridge (KcsInterface) for XHR interception and canvas screenshot capture, and a side panel for game controls (refresh, mute, screenshot, rotation lock, subtitles, logout). It integrates third-party mods (60 FPS unlock, critical-hit effects, 3D models, language patches) by regex-patching the game's main.js at load time, and supports picture-in-picture, multi-window, gesture controls, and IP-block bypass via proxy override. Architecturally it is a standard Android app: three Activities (EntranceActivity for connector selection, BrowserActivity for the game, SettingsActivity for preferences), a WebViewManager that configures the browser, a ResourceProcess that intercepts and caches all game resource requests, and a KcaContentProvider that broadcasts game API data to companion apps like Kcanotify. The subtitle system uses a clean strategy pattern (SubtitleProvider interface with kc3-translations GitHub and kcwiki API implementations) to display translated voice lines. External dependencies include DMM game servers, OOI proxy connectors, GitHub (version checks, subtitle data, mod sources), kcwiki, and Firebase Crashlytics. The app is actively maintained (last commit 2026-09-11) and well-localized (8 languages), but it carries inherent fragility: the regex-based patchers break whenever the game updates main.js, and the app depends on external services (GitHub, kcwiki, bypass endpoints) that may change or rate-limit. There are no automated tests, and the resource caching logic in ResourceProcess is complex and error-prone. Legacy jniLibs for dead architectures (mips, armeabi) remain in the tree. Despite the niche domain, a few components are genuinely reusable: WebViewL (a WebView that keeps rendering when invisible), VersionDatabase (a generic SQLite key-value store with version tracking), and the SubtitleProvider abstraction (a clean multi-source data fetching pattern). The patcher classes demonstrate a modular, independently toggleable patching design, though they are game-specific.

Airtest is a cross-platform UI automation testing framework developed by NetEase, primarily targeting mobile games and apps. It provides a unified Python API and CLI for automating interactions on Android, iOS, Windows, and Linux devices. The core mechanism is image recognition using computer vision algorithms (template matching, keypoint matching with SIFT/KAZE/BRISK, etc.) to locate UI elements, combined with device-specific input simulation via ADB, minitouch, WebDriverAgent, and pywinauto. The framework supports complex gestures, multi-touch, screen recording, and HTML report generation with step logs and screenshots. Architecturally, Airtest is a library with a CLI entry point (`airtest run/report/info`). It uses a device abstraction layer with platform-specific implementations (Android, IOS, Windows, Linux) that share a common API through `airtest.core.api`. The image matching is handled by the `aircv` subpackage, which offers multiple matching strategies configurable via `CVSTRATEGY`. The Android module employs a proxy pattern for screen capture (Minicap, Javacap, ADB) and touch input (Minitouch, Maxtouch, ADB), allowing runtime switching. The framework also integrates with the Poco UI hierarchy inspection tool and supports cloud device testing. While the primary focus is application testing, the repository includes a small benchmark directory that compares the performance of various image matching algorithms, producing metrics like CPU, memory, and keypoint counts. This is a minor component and does not shift the overall classification away from application. The codebase is well-structured with clear separation of concerns, but shows signs of technical debt such as Python 2 compatibility shims, pinned outdated dependencies (opencv-contrib-python ≤ 4.6.0.66, numpy < 2.0), and bundled precompiled binaries (minitouch, minicap, iproxy) that require periodic updates. The project is actively maintained with frequent commits and community engagement, but test coverage is limited due to reliance on real devices.

This repository is a proxy subscription aggregation and distribution system. It periodically collects free proxy subscription links (Clash YAML and V2Ray URI formats) from multiple public sources, merges them, classifies nodes by TCP connectivity (reachable/unreachable/untested), and serves the resulting files via a Cloudflare Worker. The system is driven by a GitHub Actions workflow that runs every 12 hours, executing Python scripts to fetch, process, and commit updated subscriptions. The architecture is a data pipeline application with a serverless serving layer. Key entry points include main.py (orchestrating collection and merging), check_nodes.py (TCP connectivity classification), and worker/sub.mjs (Cloudflare Worker for serving with caching and ETag). External dependencies include requests, PyYAML, and the Cloudflare Workers runtime. The repository also includes a weekly commit history cleanup workflow to keep repository size small. The project is actively maintained with frequent updates and tests, though it relies on unstable external proxy sources.

Cashew is a production-grade, cross-platform personal finance and budget tracking application built with Flutter/Dart. It manages transactions, multi-currency wallets, budgets with category-level spending limits, savings goals and loans, subscriptions, recurring/auto-pay rules, credit/debt tracking, and spending analytics (pie charts, line graphs, heatmaps, net worth summaries). It ships to Android (with home screen widgets), iOS, web (PWA), and desktop. Data persists locally in SQLite via the Drift ORM with 46 managed schema migrations, and synchronizes across devices through a custom Google Drive sync client, with shared-budget features on Firebase Auth/Firestore/Cloud Functions, plus optional Gmail and notification scanning for auto-generated transactions.

This is an Android Xposed module (using LSPosed/libxposed API) that hooks system APIs to bypass eSIM (Embedded SIM / eUICC) support checks and intercept activation codes. It forces `PackageManager.hasSystemFeature` for eUICC to return true, returns a fake EuiccService in query results, and captures activation codes from `DownloadableSubscription.forActivationCode` or `getEncodedActivationCode`, copying them to the clipboard and offering to share via an Intent. Additionally, it provides an OMAPI bypass by hooking `com.android.se.security.AccessControlEnforcer` to disable ARF/ARA access control, enabling OMAPI access without proper ARA rules. The module targets specific packages listed in `scope.list` (com.android.se, com.miui.euicc, app.septs.euiccprobe). The code is a single Java class (`HookEuicc.java`) that extends `XposedModule` and installs hooks in `onPackageReady`. It demonstrates solid reflection-based hooking patterns and includes a reusable utility method for setting boolean fields via reflection across the class hierarchy. The build system uses Gradle with Android Gradle Plugin 8.6.0 and targets Android SDK 35.

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.

ProjectX is an Android multi-module repository containing a support library (`support`, `support_v1`) and demo applications (`app`, `app_old`). The support library provides a wide range of reusable utilities, UI components, security helpers, and builder patterns for Android development, published as a Maven artifact. The demo app showcases these components through interactive activities organized by category (widgets, drawables, others), using an MVP-like architecture. The codebase demonstrates strong engineering practices with fluent builders, composable conditions, and view recycling patterns, but carries legacy baggage from duplicate modules and deprecated classes. The last commit is recent, indicating ongoing maintenance, though some technical drift is present due to reflection usage and outdated API references.

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.

APKDeepLens is a Python-based CLI static analysis tool for Android APK security assessment. It decompiles APKs using bundled JADX, analyzes AndroidManifest.xml for misconfigurations, scans decompiled source code for OWASP Mobile Top 10 vulnerabilities, detects hardcoded secrets and insecure URLs, and generates reports in JSON/HTML/PDF/TXT formats. The architecture is monolithic with modular components for manifest analysis, code scanning, secret extraction, and report generation. Entry point is APKDeepLens.py with argparse CLI interface. External dependencies include JADX (bundled), xhtml2pdf for PDF generation, and python-bidi for PDF rendering.

Yaxim is an Android-based XMPP/Jabber instant messaging client. It maintains a persistent XMPP connection via a background service (XMPPService) using the Smack library, with UI components binding to the service for message exchange and roster management. The app features multiple product flavors (main, branded, F-Droid, Google Play variants) and supports core XMPP extensions including MAM, Carbons, and Message Archiving. Data persistence is handled through SQLite ContentProviders for chat history and roster management. The application demonstrates a clean separation of concerns between networking, data storage, and UI layers, though it shows signs of technical drift due to reliance on deprecated Android Support Libraries and outdated APIs like Android Beam.

This repository provides an ARM64 tracing and emulation workflow based on the Unicorn engine, designed to work as an IDA Pro plugin and with standalone replay capabilities. The system allows users to trace ARM64 code execution within IDA, dump memory segments, generate Tenet-compatible logs for analysis, and replay traces offline. Key features include dynamic code simulation, memory dumping, register state tracking, instruction-level logging, and special handling for ARM64-specific instructions like MRS TPIDR_EL0 and AUTIASP. The architecture separates IDA integration (dyn_trace_ida.py) from core emulation logic (unicorn_trace/unicorn_class.py), enabling both interactive tracing within IDA and offline replay of captured traces.

Il2CppMemoryDumper is a shell script designed to extract Il2Cpp metadata and native libraries from the memory of a running Android process. It operates by scanning the target process's memory maps for regions associated with libil2cpp.so, global-metadata.dat, and split-config APKs, then dumps these regions to files after verifying their content via magic number checks. The script includes logic to merge adjacent memory regions for ELF files and handle anonymous .bss sections, outputting files with naming conventions based on memory offsets. It is intended for use in a rooted Android shell environment and relies solely on standard Linux utilities (awk, bc, dd, grep, etc.) without external dependencies.

This repository is a React Native library that provides platform-specific camera and image/video picker functionality. It exposes two primary functions: `launchCamera` and `launchImageLibrary`, which allow users to capture photos/videos or select existing media from the device library. The implementation covers iOS (using UIImagePickerController and PHPickerViewController), Android (via Intents and the AndroidX Photo Picker), and a minimal web fallback using browser APIs. The library handles image resizing, metadata extraction, video conversion, permission handling, and offers configurable options like quality, media type, selection limits, and more. The codebase follows standard React Native native module patterns with support for both the old and new architecture (TurboModules). While the implementation is functional and well-tested by the community, it includes some code that could be considered dated (e.g., synchronous dispatch semaphore on iOS, inline DOM manipulation on web) and does not contain easily extractable reusable components outside its specific domain.

EKA2L1 is a Symbian OS emulator written in C++17, targeting the EKA2 (and EKA1) kernel used by Nokia S60 smartphones and N-Gage devices. It provides full system emulation including ARM CPU (with multiple backends: dyncom interpreter, 12l1r JIT, and optional Dynarmic), memory management (flexible and multiple address-space models), kernel reimplementation (processes, threads, IPC, timers, libraries), file system, and a wide range of Symbian services (window server, audio, Bluetooth, SMS, camera, DRM, etc.). The emulator supports multiple frontends: a Qt desktop application, an Android app (Java/JNI), and an iOS app (SwiftUI). It also includes a Lua scripting API for runtime debugging and game-specific patches, a GDB stub for remote debugging, and a set of guest-side DLL patches that redirect Symbian hardware calls to the emulator. The codebase is large and complex, with many services partially implemented or stubbed. It is actively maintained but development is part-time, and some platform-specific backends (e.g., iOS, Android) may lag behind the Qt frontend.

This repository is an unofficial fork of J2ME-Loader, a Java ME (J2ME) emulator for Android. It enables running MIDlets (Java ME applications) on Android devices by implementing J2ME APIs (LCDUI, M3G, MMAPI, etc.) and using native C++ components via JNI for performance-critical sections like 3D rendering (M3G) and audio synthesis (Sonivox, TSF). The emulator includes a user interface for browsing and launching MIDlets, configuring settings, and handling permissions. It also features a dex manipulation library (dexlib) for processing DEX files to ensure compatibility with Android ART. While the emulator is functional and demonstrates solid engineering practices, it shows signs of technical drift due to deprecated Android APIs and a forked dex library that may lag behind upstream, and maintenance appears stale based on commit frequency.