RxAndroid: Reactive Extensions for Android - Deployment Guide

Prerequisites

Before getting started with RxAndroid, ensure you have the following:

• Android Studio (latest stable version recommended)
• Java Development Kit (JDK) 8 or higher
• Android SDK with API level 21 or higher
• Gradle (included with Android Studio)
• RxJava 3 (required dependency)

Installation

1. Clone the Repository

git clone git@github.com:ReactiveX/RxAndroid.git
cd RxAndroid/

2. Add Dependencies to Your Android Project

Add the following to your build.gradle (Module: app) file:

dependencies {
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'
    // Recommended: explicitly depend on RxJava for bug fixes and new features
    implementation 'io.reactivex.rxjava3:rxjava:3.1.5'
}

3. Build the Project

./gradlew build

4. Sample Application

A sample project demonstrating usage is available in the sample-app/ folder. You can run it directly in Android Studio.

Configuration

Environment Variables

No specific environment variables are required for RxAndroid itself. However, ensure your Android project is properly configured:

• Android SDK location in local.properties
• Gradle properties in gradle.properties
• API keys for any external services you integrate with RxAndroid

Android Manifest

No special permissions are required for RxAndroid core functionality. Add permissions only if your specific use case requires them (e.g., internet access for network operations).

Build & Run

Development Build

./gradlew assembleDebug

Production Build

./gradlew assembleRelease

Running the Sample App

1. Open the project in Android Studio
2. Navigate to sample-app/ folder
3. Connect an Android device or start an emulator
4. Click the "Run" button or use the shortcut Shift+F10

Testing

./gradlew test

Deployment

Platform Recommendations

Since RxAndroid is a library for Android applications, deployment involves publishing your Android app to:

1. Google Play Store - Primary distribution channel
2. Amazon Appstore - Alternative Android marketplace
3. Direct APK distribution - For enterprise or side-loaded apps

Build Variants

RxAndroid supports different build variants:

• Debug - For development and testing
• Release - For production deployment
• Custom variants - Define in build.gradle if needed

Signing Configuration

For production releases, configure signing in your build.gradle:

android {
    signingConfigs {
        release {
            storeFile file("your_keystore.jks")
            storePassword "your_password"
            keyAlias "your_alias"
            keyPassword "your_password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

Troubleshooting

Common Issues and Solutions

1. Dependency Conflicts

Issue: Version conflicts between RxAndroid and RxJava Solution: Explicitly specify compatible versions in your build.gradle:

implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'
implementation 'io.reactivex.rxjava3:rxjava:3.1.5'

2. Main Thread Operations

Issue: Performing long-running operations on the main thread Solution: Use proper schedulers:

Observable.just("data")
    .subscribeOn(Schedulers.io())           // Background thread
    .observeOn(AndroidSchedulers.mainThread()) // Main thread for UI
    .subscribe(result -> {
        // Update UI here
    });

3. Looper-Related Issues

Issue: Using AndroidSchedulers.from() with incorrect Looper Solution: Ensure you're using the correct Looper:

// Main thread
AndroidSchedulers.mainThread()

// Specific Looper
AndroidSchedulers.from(backgroundLooper)

// From any Handler
AndroidSchedulers.from(handler.getLooper())

4. Memory Leaks

Issue: Subscriptions not properly disposed Solution: Use CompositeDisposable or MainThreadDisposable:

private final CompositeDisposable disposables = new CompositeDisposable();

@Override
protected void onDestroy() {
    super.onDestroy();
    disposables.clear(); // Dispose all subscriptions
}

5. Build Failures

Issue: Gradle build fails with missing dependencies Solution:

• Sync project with Gradle files in Android Studio
• Check internet connectivity
• Verify repository configuration in build.gradle:

repositories {
    mavenCentral()
}

6. Threading Issues

Issue: UI updates from background threads Solution: Always observe on main thread for UI operations:

observable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe();

Getting Help

• GitHub Issues: https://github.com/ReactiveX/RxAndroid/issues
• Google Group: RxJava
• StackOverflow: rx-android

Performance Tips

1. Use observeOn() only when necessary to minimize thread switching
2. Prefer subscribeOn() at the source of your Observable chain
3. Use CompositeDisposable for managing multiple subscriptions
4. Consider backpressure strategies for high-frequency data streams

This guide provides a comprehensive overview of deploying and using RxAndroid in your Android projects. For more advanced usage patterns, refer to the sample application and official documentation.