WAIT — Slowing — last commit 3mo ago

• Last commit 3mo ago
• 14 active contributors
• Apache-2.0 licensed
• Tests present
• ⚠ Slowing — last commit 3mo ago
• ⚠ Concentrated ownership — top contributor handles 78% of recent commits
• ⚠ No CI workflows detected
• ⚠ Scorecard: default branch unprotected (0/10)

_{Computed from maintenance signals — commit recency, contributor breadth, bus factor, license, CI, tests, cross-checked against OpenSSF Scorecard}

RxJava2-Android-Samples is a practical learning repository demonstrating RxJava 2 operators and reactive patterns for Android development. It provides 25+ executable Activities (MapExampleActivity, FilterExampleActivity, FlatMapExampleActivity, etc.) showing how to use operators like map, filter, flatMap, buffer, concat, debounce, and subjects (PublishSubject, BehaviorSubject, ReplaySubject) in real Android code. The project solves the problem of understanding reactive programming through concrete, runnable examples rather than abstract documentation. Monolithic Android app structure: app/src/main/java follows com.rxjava2.android.samples package hierarchy with three main sections: (1) ui/operators/ containing 25+ Activities demonstrating individual operators (MapExampleActivity, FilterExampleActivity, BufferExampleActivity, etc.), (2) ui/compose/ for combining operators with RxSchedulers, (3) ui/networking/ for HTTP integration, (4) ui/cache/ with MemoryDataSource, DiskDataSource, NetworkDataSource for multi-tier caching patterns. Models sit in app/src/main/java/com/rxjava2/android/samples/model/.

Android developers learning RxJava 2 for the first time or migrating from RxJava 1.x who need working code examples. Specifically: junior developers building Android apps, developers implementing reactive data streams, and engineers learning how to handle asynchronous operations using the Reactive Streams specification.

Mature and educationally focused but not actively maintained for latest Android versions. The repo uses AndroidX (androidx.appcompat, androidx.recyclerview) and RxJava 2.2.2 / RxAndroid 2.1.0 (from 2018 era), has comprehensive examples of 25+ operators with no unit test coverage visible, and appears last updated years ago. Verdict: Production-ready as educational material but outdated as a template for modern Android (SDK target 28 is 5+ years old).

Low technical risk for learning purposes, but production risk if used as a template: RxJava 2.2.2 is not the latest stable (3.x exists), no automated test suite visible, single-maintainer repository (Amit Shekhar), and deprecated AndroidX RC versions (1.0.0-rc02). No visible CI/CD configuration or issue tracking. If adopting code patterns, verify against current RxJava 3.x and modern Android best practices.

No active development visible. The repository appears frozen at a stable educational state with 25+ completed operator examples and no pending PRs or recent commits mentioned in provided metadata.

Clone and build via Gradle: git clone https://github.com/amitshekhariitbhu/RxJava2-Android-Samples.git && cd RxJava2-Android-Samples && ./gradlew assembleDebug. Import into Android Studio as an existing Gradle project. Requires Android SDK 28+ (specified in build.gradle compileSdkVersion 28).

Daily commands: Open project in Android Studio → Select emulator or device → Run app menu → Choose SelectionActivity (entry Activity) to browse operator examples. Alternatively: ./gradlew installDebug && adb shell am start -n com.rxjava2.android.samples/.ui.SelectionActivity

• app/src/main/java/com/rxjava2/android/samples/ui/SelectionActivity.java: Entry point Activity listing all 25+ operator examples; start here to navigate examples
• app/src/main/java/com/rxjava2/android/samples/ui/operators/MapExampleActivity.java: Foundational operator example showing how to transform emitted items; template for other operator Activities
• app/src/main/java/com/rxjava2/android/samples/ui/operators/FlatMapExampleActivity.java: Critical example of flattening nested Observables; essential for async chaining patterns
• app/src/main/java/com/rxjava2/android/samples/ui/cache/CacheExampleActivity.java: Demonstrates practical multi-tier caching (memory→disk→network) using reactive composition
• app/src/main/java/com/rxjava2/android/samples/ui/operators/PublishSubjectExampleActivity.java: Shows Subject pattern for hot observables and multicast scenarios
• app/build.gradle: Specifies RxJava 2.2.2, RxAndroid 2.1.0 versions and AndroidX dependencies; essential for setting up local environment

To add a new operator example: (1) Create new Activity file at app/src/main/java/com/rxjava2/android/samples/ui/operators/[OperatorName]ExampleActivity.java following pattern from existing files (e.g., MapExampleActivity.java), (2) Register in AndroidManifest.xml, (3) Add to SelectionActivity's operator list. To modify caching logic: edit files in app/src/main/java/com/rxjava2/android/samples/ui/cache/source/ (DataSource.java interface, implementations). Networking examples: modify app/src/main/java/com/rxjava2/android/samples/ui/networking/NetworkingActivity.java.

No significant hidden traps. Straightforward educational repo. Minor note: Activities assume Android SDK 28+ (targetSdkVersion 28, compileSdkVersion 28) so older emulators may have issues. Some example Activities (NetworkingActivity.java) likely depend on network connectivity or mock servers not documented in this metadata.

• Reactive Streams Specification — RxJava 2.0 is built on Reactive Streams; understanding Publisher/Subscriber/Subscription contracts is essential to grasp why RxJava 2 differs from 1.x
• Cold vs Hot Observables — Examples demonstrate both: Observable (cold, lazy subscription per subscriber) and Subject (hot, shared emissions); critical for avoiding subscription side effects in production code
• Backpressure and Flowable — FlowableExampleActivity.java introduces Flowable for handling fast producers and slow consumers; essential for preventing OutOfMemoryError in real data streams
• Subject Types (Publish, Behavior, Async, Replay) — Four Activities (PublishSubjectExampleActivity, BehaviorSubjectExampleActivity, AsyncSubjectExampleActivity, ReplayExampleActivity) show distinct caching/emission semantics; foundational for event bus and state management patterns
• Operator Composition and FlatMap — FlatMap and ComposeOperatorExampleActivity.java demonstrate chaining asynchronous operations; the pattern replaces callback hell and is critical for Android networking + data transformation
• Scheduler Threading (Computation, IO, Main) — RxSchedulers.java abstracts Observable/Subscribe thread assignment; understanding subscribeOn() vs observeOn() is essential to prevent ANR (Application Not Responding) on Android's main thread
• Disposable and Resource Cleanup — DisposableExampleActivity.java shows why unsubscribe/dispose is mandatory; memory leaks in Android occur when Observable subscriptions outlive Activity lifecycle

• ReactiveX/RxJava — Official RxJava 2.x repository; canonical source for operator documentation and implementation details
• ReactiveX/RxAndroid — Official RxAndroid library that bridges RxJava to Android Schedulers and lifecycle; required dependency for this project
• jakewharton/RxBinding — Provides RxJava 2 bindings for Android UI widgets (View clicks, TextChanges) extending the reactive patterns shown in this repo
• amitshekhariitbhu/Android-Clean-Architecture — Same author's advanced repo showing RxJava integration into MVVM/clean architecture; natural progression from this learning repo
• square/retrofit — HTTP client library often paired with RxJava 2 for networking (alternative to FastAndroidNetworking used in this repo)

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for RxBus implementation and Subject examples

The repo contains ui/rxbus/RxBus.java and multiple Subject example activities (AsyncSubjectExampleActivity, BehaviorSubjectExampleActivity, PublishSubjectExampleActivity, ReplaySubjectExampleActivity) but lacks unit tests. These are critical reactive patterns that need verification. Testing RxBus behavior (subscription, emission, disposal) and Subject state management would ensure the examples are correct and help new contributors understand expected behavior.

• [ ] Create app/src/test/java/com/rxjava2/android/samples/ui/rxbus/RxBusTest.java with tests for publish, subscribe, and disposal
• [ ] Create app/src/test/java/com/rxjava2/android/samples/ui/operators/SubjectsTest.java testing AsyncSubject, BehaviorSubject, PublishSubject, and ReplaySubject behavior
• [ ] Add TestObserver-based assertions for emission sequences and timing
• [ ] Update build.gradle to include testImplementation 'io.reactivex.rxjava2:rxjava:2.2.2' and 'junit:junit:4.12' if missing

Add integration tests for the caching layer (Memory/Disk/Network data sources)

The repo has a sophisticated caching example in ui/cache/ with three data sources (MemoryDataSource, DiskDataSource, NetworkDataSource) orchestrated by DataSource.java, but no tests verify the fallback chain or cache behavior. This is a complex real-world pattern that deserves androidTestImplementation tests to ensure the layered caching strategy works correctly and serve as documentation.

• [ ] Create app/src/androidTest/java/com/rxjava2/android/samples/ui/cache/CacheLayerTest.java
• [ ] Add tests verifying fallback order: Memory → Disk → Network
• [ ] Add tests for Data model serialization/deserialization with Disk source
• [ ] Verify disposal and proper subscription cleanup across all three sources
• [ ] Update build.gradle if needed to ensure androidTestImplementation dependencies are present

Add GitHub Actions CI workflow for automated testing on PR submissions

The repo has no CI/CD pipeline (.github/workflows/ directory is absent). Given that this is an educational repository with 40+ example activities and multiple test scenarios, adding a GitHub Actions workflow to run unit and instrumentation tests on each PR would catch regressions, validate examples work correctly, and enforce code quality standards before merge.

• [ ] Create .github/workflows/android-tests.yml with Android Gradle build and test steps
• [ ] Configure workflow to run on pull_request and push to main branch
• [ ] Include steps for: gradle build, unit tests (./gradlew test), and instrumentation tests (./gradlew connectedAndroidTest) using Android emulator or cloud device testing
• [ ] Add workflow status badge to README.md
• [ ] Optionally add lint checks with ./gradlew lint step

• Add unit tests for operator examples: Create a test suite in app/src/test/java covering MapExampleActivity, FilterExampleActivity, and FlatMapExampleActivity to verify observable emissions and subscriptions.
• Document Flowable backpressure example: FlowableExampleActivity.java exists but lacks inline comments explaining demand(), onBackpressureBuffer(), and why Flowable differs from Observable; add detailed comments and a companion blog post link.
• Add RxJava 3.x migration guide: Create MIGRATION.md showing breaking changes from RxJava 2.2.2 to 3.x (package names, API changes) with code diffs from example Activities so users can learn modern patterns.

This RxJava2 Android sample project has significant security concerns primarily due to outdated dependencies and build configurations dating from 2018. The compilation against SDK 28 with minSdkVersion 16 exposes the application to numerous known vulnerabilities in older Android versions. All core dependencies (RxJava2, RxAndroid, AndroidX) require urgent updates. Code obfuscation is disabled in release builds, and testing frameworks use unstable alpha versions. While the project appears to be a learning/sample application rather than production code, these issues would be critical if deployed. The codebase lacks visible network security hardening measures. Immediate action is needed to update all dependencies and modernize the build configuration to meet current Android security standards.

• High · Outdated Dependencies with Known Vulnerabilities — app/build.gradle. The project uses outdated versions of RxJava2 (2.2.2 from 2018) and RxAndroid (2.1.0 from 2018). These versions contain known security vulnerabilities and lack security patches. The AndroidX dependencies are also outdated (1.0.0-rc02 from 2018). Fix: Update all dependencies to their latest stable versions: RxJava2 to 2.2.8+ or RxJava3, RxAndroid to 2.1.1+, and AndroidX libraries to current stable releases (androidx.appcompat:appcompat:1.6.1+, androidx.recyclerview:recyclerview:1.3.1+)
• High · Deprecated Build Tools and SDK Versions — app/build.gradle. The project targets compileSdkVersion 28 and buildToolsVersion 28.0.2 (released in 2018). These versions are outdated and no longer receive security updates. minSdkVersion 16 is extremely old (Android 4.1, released 2012) and exposes the app to many known vulnerabilities in older Android versions. Fix: Update compileSdkVersion to at least 34, buildToolsVersion to 34.0.0+, and increase minSdkVersion to at least 24 (Android 7.0). Consider targeting minSdkVersion 26+ for modern security standards.
• Medium · Proguard Configuration Not Enabled for Release Builds — app/build.gradle (buildTypes.release section). The build configuration has minifyEnabled set to false in release builds. This means the app is not obfuscated, making it vulnerable to reverse engineering and code analysis attacks. Fix: Set minifyEnabled to true and properly configure proguard-rules.pro to enable code obfuscation and optimization in release builds.
• Medium · Outdated Testing Dependencies — app/build.gradle (testImplementation and androidTestImplementation). Test dependencies are from 2018 (espresso-core:3.1.0-alpha4, androidx.test:runner:1.1.0-alpha4). Using alpha/unstable versions for testing infrastructure is not recommended for production code. Fix: Update to stable testing library versions: androidx.test.espresso:espresso-core:3.5.1+, androidx.test:runner:1.5.2+, androidx.test:rules:1.5.0+
• Low · Missing Network Security Configuration — app/src/main/AndroidManifest.xml and app/src/main. The AndroidManifest.xml file structure is present but there's no indication of a network_security_config.xml file to enforce HTTPS and certificate pinning for network communications, especially important since the app uses rx2-android-networking. Fix: Create a network_security_config.xml file with enforcement of HTTPS, proper certificate validation, and consider implementing certificate pinning for known API endpoints.
• Low · No Permission Validation Documentation — app/src/main/AndroidManifest.xml. The manifest file contains app components but without reviewing the actual AndroidManifest.xml content, it's unclear if requested permissions follow the principle of least privilege or if runtime permissions are properly handled. Fix: Ensure all requested permissions follow the principle of least privilege. For targetSdkVersion 28+, implement proper runtime permission handling for sensitive permissions (INTERNET, LOCATION, CAMERA, etc.)

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/amitshekhariitbhu/RxJava2-Android-Samples shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live amitshekhariitbhu/RxJava2-Android-Samples repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/amitshekhariitbhu/RxJava2-Android-Samples.

What it runs against: a local clone of amitshekhariitbhu/RxJava2-Android-Samples — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in amitshekhariitbhu/RxJava2-Android-Samples | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | Last commit ≤ 133 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of amitshekhariitbhu/RxJava2-Android-Samples. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/amitshekhariitbhu/RxJava2-Android-Samples.git
#   cd RxJava2-Android-Samples
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of amitshekhariitbhu/RxJava2-Android-Samples and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "amitshekhariitbhu/RxJava2-Android-Samples(\\.git)?\\b" \\
  && ok "origin remote is amitshekhariitbhu/RxJava2-Android-Samples" \\
  || miss "origin remote is not amitshekhariitbhu/RxJava2-Android-Samples (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 133 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~103d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/amitshekhariitbhu/RxJava2-Android-Samples"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.