Chucker is a production-grade Android library for inspecting HTTP(S) traffic in-app. It acts as an OkHttp interceptor, capturing full request/response details (headers, bodies, timing, errors) and persisting them to a local Room database. The library provides a built-in Material Design UI for browsing, searching, filtering, and exporting transactions (HAR 1.2, plain text, curl commands). It is designed as a debug-only tool via a no-op variant for release builds. The architecture follows a clean separation: public API (ChuckerInterceptor, ChuckerCollector, BodyDecoder), internal data layer (Room entities, DAO, repository), support utilities (okio stream manipulation, JSON formatting, background services), and a full set of UI fragments/adapters. The codebase is well-tested (unit tests for interceptors, DAO, repository, utilities, ViewModels) and follows modern Android development practices (Kotlin, Coroutines, LiveData/Flow, ViewBinding, Compose sample). It handles edge cases like compressed bodies, large payloads, binary formats (protobuf), GraphQL, and SSL/TLS information. The project also includes CI/CD pipelines, automated dependency updates via Renovate, and migration guides for previous versions. While primarily an application library, it has a strong data storage component (Room database) and export functionality (HAR generation), making it useful for debugging network issues in any Android app.
This repository is a Java/Kotlin client library for the Telegram Bot API, providing type-safe wrappers for all bot API methods and models. The architecture is a classic library with a fluent builder pattern: users create request objects (e.g., `SendMessage`, `GetUpdates`), execute them via the `TelegramBot` class, and receive typed responses. The library handles both synchronous and asynchronous execution, supports long-polling and webhook modes, and includes Telegram Passport encryption/decryption utilities. The codebase is well-structured, with clear separation into model, request, response, and utility packages. It features custom Gson adapters for polymorphic API types (e.g., reaction types, chat boost sources) that demonstrate a clean discriminated union deserialization pattern. The library is actively maintained, tracking Telegram Bot API updates closely, and includes Kotlin extension functions for idiomatic usage. It is not a data research project; it is purely an integration library.
Fuel is a Kotlin Multiplatform HTTP networking library built on kotlinx.coroutines, providing suspend-style HTTP verbs (GET, POST, PUT, PATCH, DELETE, HEAD, arbitrary methods) plus Server-Sent Events streaming across JVM, Apple (iOS/macOS), and WasmJS targets. The core fuel module uses an expect/actual split: a common HttpLoader interface and FuelBuilder are backed by OkHttp on JVM, NSURLSession on Apple, and the browser fetch API on WasmJS. A global Fuel object supports plugging in a custom loader or loader factory, and extension functions on String (httpGet(), httpPost(), etc.) provide concise request entry points. A FuelRouting interface lets applications model typed API endpoints as sealed classes. Four optional serialization modules — fuel-jackson-jvm, fuel-moshi-jvm, fuel-kotlinx-serialization, and fuel-forge-jvm — each add a small extension on HttpResponse (toJackson, toMoshi, toJson, toForge) that decodes the body and returns a Result from the companion Result library. The core response model is deliberately minimal: a mutable HttpResponse holding a status code, a kotlinx.io Source body stream, and headers. JVM request handling is semantically correct about HTTP (e.g., consulting OkHttp's HttpMethod.permitsRequestBody before attaching a body). The project is published as 3.0.0-alpha04, uses Kotlin 2.3 / Gradle 9.3 / OkHttp 5 alpha, and is actively maintained with CI, Renovate, Dependabot, and ktlint. JVM has solid unit coverage using MockWebServer for all verbs, routing, custom OkHttp configurations, and each serialization adapter. Apple and Wasm targets are implemented but largely untested outside manual samples, and the Apple SSE implementation is a naive full-body line splitter rather than true incremental streaming. Overall this is a clean, modern, well-organized library with a couple of genuinely reusable pieces (notably the Android-derived UriCodec port) and some pre-1.0 rough edges. This is a pure application/library repository, not a data project.
This is a Spring Boot starter library that deeply integrates Square's Retrofit HTTP client with Spring Boot's auto-configuration, allowing developers to declare typed HTTP APIs via Java interfaces annotated with `@RetrofitClient`. The library provides a comprehensive set of features: automatic OkHttpClient management, a pluggable interceptor chain (global, network, path-match), configurable retry with exponential backoff and jitter, circuit breaking (via Sentinel or Resilience4j), logging strategies, Micrometer metrics, custom error decoding, and connection pooling. It also supports Spring Boot Actuator for runtime introspection, GraalVM native image/AOT compilation, and reactive call adapters (RxJava 2/3, Reactor). The architecture is modular with clear SPIs for extensibility (e.g., `SourceOkHttpClientRegistrar`, `GlobalInterceptor`, `RetrofitDegrade`, `ErrorDecoder`), and the configuration is annotation-driven with global defaults overridable per-client. The codebase is well-tested with integration tests using MockWebServer, and documentation is provided in multiple languages. However, the tight coupling to specific versions of Retrofit, OkHttp, and Spring Boot introduces moderate technical drift, as some optional dependencies (e.g., Sentinel 1.8.6, Resilience4j 1.7.1) are older. The library is primarily a framework integration rather than a standalone application, but its design patterns serve as a reference for building Spring Boot auto-configuration with complex SPI chains.
This repository is an Android application that bridges device events (SMS, MMS, missed calls, battery changes, app notifications) to a Telegram bot for monitoring and remote control. It uses the Telegram Bot API to forward events and long-polls for incoming commands to send SMS, USSD, list/read/delete SMS, fetch logcat, and more. The architecture is a monolith with multiple background services, broadcast receivers, and job scheduler jobs, all within a single Android app. It uses MMKV for key-value storage, OkHttp for HTTP, Gson for serialization, and libsodium for encryption. The codebase is well-structured with reusable utility classes (e.g., custom Mustache template engine, Telegram API wrapper, encryption helpers) and has unit tests for several components. It supports multi-language, QR code configuration import, and carbon-copy forwarding to external services via HAR format.
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.