liujingxing/rxhttp

RxHttp is an Android HTTP client library that provides a reactive API for making network requests using RxJava, Kotlin Coroutines (Await/Flow), and standard Java. It features compile-time code generation via KSP and Kapt to create type-safe request builders, supporting diverse serialization formats and custom converters. The system includes built-in capabilities for file downloads with progress monitoring, caching, cookie management, and structured concurrency.

13 changes.

The project was renamed to RxHttp and significantly expanded with new features including coroutine-based APIs, built-in caching, cookie management, and support for multiple serialization formats. Concurrently, a comprehensive demo application was scaffolded to showcase these capabilities, featuring multi-task downloads, encryption examples, and structured error handling.

7 changes.

The compiler was migrated from Kapt to KSP to consolidate build logic and add support for RxJava 3 and non-Android platforms. The demo application was updated to align with the new RxHttp 3.0.3 API, introducing multi-task download implementations across RxJava, Coroutines Await, and Flow paradigms.

7 changes.

The project migrated its annotation processing from Kapt to KSP 2.0, introducing a new code generation architecture with fluent Kotlin wrappers and enhanced RxJava progress callbacks. This period also expanded library capabilities by adding kotlinx.serialization support and improving compiler utilities for better type handling and exception management.

The library now includes Android10DownloadFactory to handle scoped storage on Android 10+ by querying existing URIs to prevent filename conflicts, while falling back to legacy file paths on older versions. Additionally, ResponseParser is introduced to standardize API responses with a 'code' and 'data' structure, automatically throwing ParseExceptions on errors and supporting generic types like PageList.

app/src/main/java/com/example/httpsender/parser · high confidence

New Java parser classes (ResponseParser and DoubleTypeParser) have been added to the library, extending TypeParser to support generic type resolution and automatic code validation. These parsers enable users to parse complex generic structures (such as pairs or nested lists) and handle response data conversion directly in Java, complementing existing Kotlin capabilities.

app/src/main/java/com/example/httpsender/parser/java · high confidence

The app now includes a custom tab indicator that applies both color transitions and scaling animations when switching between tabs. This is implemented via a new \ScaleTransitionPagerTitleView\ that extends the library's \ColorTransitionPagerTitleView\ to animate the scale of the title view based on its position, and a \FragmentPageAdapter\ to manage the associated fragments and titles for the pager.

app/src/main/java/com/example/httpsender/adapter, app/src/main/java/com/example/httpsender/view · high confidence

Added four new example parameter classes (GetEncryptParam, PostEncryptFormParam, PostEncryptJsonParam, PostEncryptJsonParam1) in the app module to demonstrate how to implement custom encryption logic for HTTP requests. These examples show how to override getHttpUrl() for GET requests and getRequestBody() for POST requests to encrypt query parameters or JSON bodies before transmission.

app/src/main/java/com/example/httpsender/param · high confidence

The KSP compiler now generates Kotlin wrapper classes (such as RxHttp, RxHttpFormParam, and RxHttpJsonParam) that provide a fluent, type-safe API for building HTTP requests. These generated classes expose methods for setting query parameters, adding form or JSON bodies, and handling file uploads, while also providing conversion methods like toObservable and execute to process responses. Additionally, extension functions are generated on BaseRxHttp and CallFactory to support Kotlin-specific features like reified type parameters for list and response parsing.

app/build/generated/ksp/debug/kotlin · high confidence

The app module introduces the core demo application structure, starting with AppHolder to initialize the RxHttpManager and enable MultiDex. RxHttpManager configures the HTTP client with SSL, cookie storage, and common parameter assembly. The UI is built around MainActivity, which hosts a ViewPager with tabs for RxJava, Await, Flow, and Multi Download examples, utilizing MagicIndicator for navigation. A new DownloadMultiAdapter provides a RecyclerView interface for managing multiple download tasks, displaying progress, speed, and estimated time. Supporting components include a LoggingEventListener for detailed OkHttp call tracing, a RedirectInterceptor for handling HTTP 308 redirects, and utility classes like ExceptionHelper for network status checks and Tip for toast notifications.

app/src/main/java/com/example/httpsender · high confidence

A new \SerializationConverter\ is introduced in the \converter-serialization\ module, enabling direct integration with \kotlinx.serialization\ for both request body encoding and response body decoding. This allows users to leverage \kotlinx.serialization\'s \StringFormat\ for handling JSON data, supporting serialization of collections, maps, and custom types, while also providing an extension function to easily convert a \StringFormat\ instance into an RxHttp converter.

rxhttp-converter/converter-serialization · high confidence

The app now includes a comprehensive set of new data models to support API interactions: Article, DownloadTask, Location, Name, NewsDataXml, NewsXml, PageList, Response, and User. Additionally, a new ErrorInfo class has been introduced to provide unified exception handling, mapping specific HTTP and network errors (such as timeouts, connection issues, and JSON parsing failures) to user-friendly messages. The Url object has also been added to centralize API endpoint definitions.

app/src/main/java/com/example/httpsender/entity · high confidence

The demo application now includes a MultiDownloadFragment for managing concurrent downloads with individual item updates, alongside a TokenInterceptor example that demonstrates automatic token refresh on failure. The library expands its serialization support by adding new converters for FastJson, Jackson, Moshi, and Protocol Buffers, while also introducing the OkResponse entity and parser to allow users to access both the deserialized body and raw HTTP headers/status in a single response object.

. · high confidence

The app now provides three distinct implementations for multi-task downloading in the \vm\ package: \MultiTaskDownloader\ (using RxJava's \toDownloadObservable\), \MultiTaskAwaitDownloader\ (using \toDownloadAwait\), and \MultiTaskFlowDownloader\ (using \toDownloadFlow\). Each implementation manages a queue of up to three concurrent download tasks, supports pausing, canceling, and resuming (via local file size checks), and updates the UI via \MutableLiveData\. This allows users to choose the reactive paradigm (RxJava, Coroutines Await, or Coroutines Flow) that best fits their architecture while maintaining consistent multi-task behavior.

app/src/main/java/com/example/httpsender/vm · high confidence

The library now includes a comprehensive caching system (configurable via \RxHttpPlugins.setCache\ with modes like \ONLY\_NETWORK\ or \READ\_CACHE\_FAILED\_REQUEST\_NETWORK\) and a \CookieStore\ for persistent cookie handling. It also adds a new coroutine-friendly API surface, exposing \CallFactory.toAwait()\ and \CallFactory.toFlow()\ methods for structured concurrency, alongside a \ProgressCallbackHelper\ to manage upload/download progress intervals.

rxhttp · high confidence

A change to existing behaviour in screen — 11 commits, 12 files.

screen · medium confidence · unverified

The app now includes a proguard-rules.pro file to handle code shrinking and obfuscation. This configuration preserves default constructors and non-transient fields in the com.example.httpsender.entity package to ensure R8 full mode compatibility, and suppresses warnings for dependencies like simple-xml and fastjson that previously caused build failures.

app · high confidence

The rxhttp-annotation module introduces several annotation enhancements to improve request configuration and data handling. The new @Converter annotation allows fields to specify a custom IConverter via the className attribute, enabling support for formats like FastJson. The @Domain and @OkClient annotations now include a className field, allowing generated request classes to default to specific base URLs or OkHttpClient instances. Additionally, the @Parser annotation gains a wrappers attribute, which generates multiple asXxx methods for flexible response parsing, while the name field in @Converter and @OkClient defaults to an empty string.

rxhttp-annotation · high confidence

The rxhttp-compiler has been upgraded to support KSP 2.0, introducing new utility files (KtUtil, ObservableUtil, StringUtil) to streamline code generation. For RxJava users, the generated ObservableCall now includes an onMainProgress method for convenient progress callbacks on the main thread and a toObservableOkResponse method to return OkResponse objects for any parser. Additionally, progress callbacks now support a configurable minimum period to control callback frequency, and the compiler fixes issues with type arrays and varargs in parser constructors while ensuring consistent exception handling across RxJava, Await, and Flow execution paths.

rxhttp-compiler/src/main/java/com/rxhttp/compiler/common · high confidence

The annotation processor has been migrated from Kapt to KSP (including KSP 2.0 support), consolidating the build logic into a single processor. This change introduces a new \rxhttp\_android\_platform\ option, allowing the library to be used in non-Android environments. Additionally, the compiler now supports RxJava 3, automatically adjusting generated code to use the \io.reactivex.rxjava3\ package structure when detected, while maintaining backward compatibility with RxJava 2.

rxhttp-compiler/src/main/java/com/rxhttp/compiler · high confidence

The demo application's HTTP sender fragments (Await, Flow, and RxJava) have been updated to align with the RxHttp 3.0.3 library changes. This includes renaming conversion methods (e.g., \asXxx\ to \toAwaitXxx\/\toFlowResponse\), adopting \toAwaitOkResponse\ for better response handling in Coroutines, and standardizing progress monitoring via \onProgress\ for Flow-based uploads. The fragments now demonstrate the latest API patterns for making GET, POST, and file upload requests using Kotlin Coroutines and RxJava.

app/src/main/java/com/example/httpsender/fragment · high confidence

The kapt compiler module now includes the full implementation for generating RxHttp Java and Kotlin code, including the BaseRxHttp generator, class helpers for parameter types, and visitors for parsing annotations like @Param, @Parser, @Domain, and @OkClient. This completes the kapt support previously merged with KSP, enabling users to benefit from compile-time code generation in kapt environments with consistent behavior across both annotation processors.

rxhttp-compiler/src/main/java/com/rxhttp/compiler/kapt · high confidence

The RxHttp compiler has been rewritten to use the Kotlin Symbol Processing (KSP) API, replacing the previous implementation. This change introduces new generated code structures, including a \BaseRxHttp\ class that provides core execution methods like \execute\ and RxJava-specific observables (\toObservable\, \toDownloadObservable\), as well as generated parameter wrapper classes (\RxHttpBodyParam\, \RxHttpFormParam\, etc.) that streamline request building. The compiler now uses dedicated visitors to process annotations such as \@Converter\, \@Domain\, and \@OkClient\, generating corresponding setter methods and validating their declarations. Additionally, custom parser handling has been updated to generate \toObservableXxx\ methods that support \OkResponse\ wrappers, allowing users to access both response bodies and headers.

rxhttp-compiler/src/main/java/com/rxhttp/compiler/ksp · high confidence

This change introduces a new set of Kotlin extension functions in the \app/src/main/java/com/example/httpsender/kt\ package to simplify common Android development tasks. It adds \startActivity\ extensions for \Activity\ and \Fragment\ to streamline intent creation with optional configuration blocks. It also provides \Throwable\ extensions (\errorCode\ and \errorMsg\) that map various HTTP and network exceptions (such as \HttpStatusCodeException\, \ParseException\, and timeout errors) to specific user-facing error messages and status codes. Additionally, \Uri\ extensions are added to query and delete media store items by display name, including logging of file metadata like ID, size, and dates.

app/src/main/java/com/example/httpsender/kt · high confidence

The project has been renamed from HttpSender to RxHttp, reflected in the updated README files and the new README\_zh.md. The documentation now specifies the latest library version (3.5.1) and dependencies, including OkHttp 4.12.0 and KSP 2.3.4. Additionally, the Gradle wrapper scripts (gradlew, gradlew.bat) and configuration files (jitpack.yml, maven\_dependency.md) have been added or updated to support the build process.

(repo-wide) · high confidence

The RxJava integration for upload and download progress has been updated to provide more detailed feedback and better control over callback frequency. The \Progress\ object now includes a \speed\ parameter, allowing users to monitor network throughput in real-time. Additionally, the \onProgress\ and \onMainProgress\ methods now accept a \minPeriod\ argument, enabling developers to set a minimum time interval between progress callbacks to prevent UI jank from excessive updates. The API also introduces \onMainProgress\ variants that allow specifying both the queue capacity and the minimum callback period, ensuring smoother performance on the main thread.

app/build/generated/ksp/debug/java · high confidence

The library now registers its annotation processor for both KSP (Kotlin Symbol Processing) and Kapt (Kotlin Annotation Processing Tool) via new service provider files. This change consolidates support, ensuring the compiler works correctly with local dependencies even when Gradle versions are upgraded to 5.x or higher, resolving previous issues where the APT processor might fail in local development scenarios.

rxhttp-compiler/src/main/resources · high confidence

Added Android instrumentation test for HTTP sender; Added unit tests for async HTTP operations and KSP processor behavior.

The Gradle wrapper configuration has been updated to use Gradle 9.3.1. This change ensures that the project builds using this specific version of the Gradle build tool, which may introduce new features, performance improvements, or breaking changes compared to previous versions.

gradle · high confidence

The project has been upgraded to Android Gradle Plugin 9.0.0 and Kotlin 2.3.10, requiring Java 17 for compilation. This update includes a comprehensive refresh of third-party dependencies, notably upgrading OkHttp to 5.3.2 and RxJava to 3.1.12, while also updating the KSP plugin to 2.3.5 to align with the new Kotlin version.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 55 (+5.1)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 93 → 93 (-0.1)
• Architecture 93 → 99 (+5.9)
• Maturity 49 → 49 (-0.1)
• Readiness 26 → 33 (+7.7)
• Security 98 → 98 (+0.0)
• Performance 100 (new)

• Documentation: no installation or build instructions
• Documentation: no licence statement
• Documentation: no usage examples
• Most significant orphaned file (rxhttp-compiler/src/main/java/com/rxhttp/compiler/common/ObservableUtil.kt)

• Duplicated block (10 lines × 3) (rxhttp/src/main/java/rxhttp/wrapper/param/FormParam.java)
• Duplicated block (13 lines × 2) (rxhttp/src/main/java/rxhttp/wrapper/entity/FileRequestBody.java)
• Duplicated block (7 lines × 2) (rxhttp/src/main/java/rxhttp/wrapper/param/JsonArrayParam.java)
• Most significant orphaned file (rxhttp-compiler/src/main/java/com/rxhttp/compiler/kapt/RxHttpGenerator.kt)
• No ADRs found

• Containers 0 added · 0 removed · contexts 7 added · 1 removed · edges 6 added · 0 removed

• app
• converter-fastjson
• converter-jackson
• converter-moshi
• converter-protobuf
• converter-simplexml
• rxhttp-compiler

• .

• app → rxhttp
• converter-fastjson → rxhttp
• converter-jackson → rxhttp
• converter-moshi → rxhttp
• converter-protobuf → rxhttp
• converter-simplexml → rxhttp

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

liujingxing/rxhttp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.