RxJava bindings for Android


RxAndroid: Reactive Extensions for Android

Android specific bindings for RxJava 3.

This module adds the minimum classes to RxJava that make writing reactive components in Android applications easy and hassle-free. More specifically, it provides a Scheduler that schedules on the main thread or any given Looper.


Since RxAndroid is part of the RxJava family the communication channels are similar:


allprojects {
    repositories {
        maven { url "https://oss.jfrog.org/libs-snapshot" }

dependencies {
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
    // Because RxAndroid releases are few and far between, it is recommended you also
    // explicitly depend on RxJava's latest version for bug fixes and new features.
    // (see https://github.com/ReactiveX/RxJava/releases for latest 3.x.x version)
    implementation 'io.reactivex.rxjava3:rxjava:3.0.0'
  • RxAndroid:
  • RxJava:

Additional binaries and dependency information for can be found at search.maven.org.


To build:

$ git clone [email protected]:ReactiveX/RxAndroid.git
$ cd RxAndroid/
$ ./gradlew build

Further details on building can be found on the RxJava Getting Started page of the wiki.

Sample usage

A sample project which provides runnable code examples that demonstrate uses of the classes in this project is available in the sample-app/ folder.

Observing on the main thread

One of the most common operations when dealing with asynchronous tasks on Android is to observe the task's result or outcome on the main thread. Using vanilla Android, this would typically be accomplished with an AsyncTask. With RxJava instead you would declare your Observable to be observed on the main thread:

Observable.just("one", "two", "three", "four", "five")
    .subscribe(/* an Observer */);

This will execute the Observable on a new thread, and emit results through onNext on the main thread.

Observing on arbitrary loopers

The previous sample is merely a specialization of a more general concept: binding asynchronous communication to an Android message loop, or Looper. In order to observe an Observable on an arbitrary Looper, create an associated Scheduler by calling AndroidSchedulers.from:

Looper backgroundLooper = // ...
Observable.just("one", "two", "three", "four", "five")
    .subscribe(/* an Observer */)

This will execute the Observable on a new thread and emit results through onNext on whatever thread is running backgroundLooper.

Bugs and Feedback

For bugs, feature requests, and discussion please use GitHub Issues. For general usage questions please use the mailing list or StackOverflow.


Copyright 2015 The RxAndroid authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at


Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
See the License for the specific language governing permissions and
limitations under the License.
  • [RFC] Improve support for auto-unsubscribing observables and newer language/API levels

    [RFC] Improve support for auto-unsubscribing observables and newer language/API levels

    Currently, using Observables in Android components that have access to Context (or are themselves) requires one to carefully think about detaching from these sequences as part of the component life-cycle, since otherwise a closure the sequence holds a (strong) reference to might leak the current context until the time the sequence finishes and releases all subscribers.

    A good example are configuration changes, where Android first destroys, then recreates an Activity, but observables might still be holding on to a subscriber created within the scope of that Activity. Even with retained fragments that detach from their host activity, it's easy enough to leak the attached context indirectly by holding on to a view first created through that context (every view in Android has a strong reference to the Activity context it was first created in.)

    This ticket aims to find solutions to improve this situation, potentially by leveraging newer Android API levels where available, and/or add first class support for newer Java language levels (Java 8/Retrolambda)

    Some suggestions that have been made already follow.

    Android 14+ APIs

    One option would be to make use of Activity life cycle callbacks: http://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks.html

    This might allows us to unsubscribe once Android is about to destroy an activity.

    Java 8 lambdas and Retrolambda

    Part of the problem is that every "lambda" in Java 7 or below is an anonymous inner class that will hold a strong reference to the outer class, even if it's a pure function that does not access state outside the lambda. Java 8 + Retrolambda could help here, since pure functions will be materialized as static methods that hold no reference back to their owner.

    http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html https://github.com/orfjackal/retrolambda

    Weak subscribers

    We've taken several stabs at this and always dismissed the solution. The idea was to use WeakReferences to bind subscribers and lambdas. The problem with his approach is that it doesn't work with lambdas, since the only incoming reference would be weak, and they are eligible for GC the instant they're created. There might still be other ways to achieve this, however, I'll leave it open for discussion.

    help wanted 
    opened by mttkay 66
  • Reactive Dialog

    Reactive Dialog

    This PR adds a DialogFragment returning an Observable.

    This allows for composition of actions over UI interactions (asking a user for data, confirmation etc..)

    This is the first PR in a series of backport from work we did. To help with comunication and my refactoring I'll issue the PR one by one as they get merged in or declined.

    opened by Dorvaryn 43
  • Proposal to add RxIdlingResource for Espresso testing

    Proposal to add RxIdlingResource for Espresso testing

    Problem: Espresso does not know about RxJava's async mechanisms, so it doesn't wait for subscriptions to finish before continuing on to the next testing step. Thereby, Espresso testing when using RxJava does not work out-of-the-box.

    Solution: I've created a RxIdlingResource class that tracks subscriptions via a RxJavaObservableExecutionHook plugin and is registered with Espresso as an IdlingResource. This gives Espresso the knowledge it needs to wait or proceed with respect to RxJava background processes.

    Also, since registering the plugin has to be done at a specific time in the startup process, I've created an RxAndroidJUnitRunner class that takes care of the setup.

    Proposal Since this project seems to fill the gaps between RxJava and the standard Android api's, it seems reasonable to add RxIdlingResource to fill the gap between RxJava and the Espresso testing framework. If everyone agrees that this belongs in the RxAndroid project I can go ahead and create a PR.

    opened by rosshambrick 35
  • Java 7

    Java 7

    Quick poll: anyone here who requires RxAndroid to support Java 6? It would be ideal if we could make a cut and drop Java 6 support. Any JARs built with language level 7 will NOT work with Android apps that are compiled against level 6, since Java 7 introduces new byte code instructions so is not backwards compatible.

    The problem is that it's easy to miss that when juggling multiple SDKs and JVMs on your dev machine. I'm using jEnv right now to do that, but we already encountered an issue where a Nebula plugin was compiled and deployed under Java 7 and would fail the RxAndroid build.

    Considering that Java 6 has reached end of life, should we support it or not? It's difficult to say, since it definitely took us a while to make the switch to Java 7 on Android.

    opened by mttkay 26
  • First attempt at adding Account Observable

    First attempt at adding Account Observable

    This is a rough draft, produced from code, I have been using for a while already.

    Note, that unlike most other operators in the library OnSubscribeAddAccount is left public to allow people to better adjust it for various needs - the code is already too sophisticated and does too much to try and stuff everything in bunch of static methods.

    Before finishing this, I would like to know answers to following questions:

    1. How do I test it? Robolectric 2.3 does not have proper shadow for AccountManager, so should I just write my own? By the way, are there plans to update to Robolectric 2.4, perhaps by employing SDK manager plugin to fetch dependencies? I am aware of #1369, but at current rate it is not going resolve itself.
    2. What are project guidelines (ok, what should those be) regarding use of annotations? Complex AccountManager methods need @Nullable annotation rather badly, but which one to choose? Android ones? IntelliJ ones (used so far, because they are easiest to get). Perhaps, something more complex (Checker Framework)?
    opened by Alexander-- 24
  • RX Android & Proguard

    RX Android & Proguard


    I ran into a small issue when releasing into pro-guard.The method AndroidSchedulers.mainThread() makes the subscription to never be called:

    This will not work (Hello will never show):

    mRestService.login(email, password)
                    .flatMap(user -> Observable.zip(
                            (v, u) -> (User) u // Pass user throught
                    .subscribe(user -> { Log.v(TAG, "Hello") }, throwable -> { });

    This works as expected :

    mRestService.login(email, password)
                    .flatMap(user -> Observable.zip(
                            (v, u) -> (User) u // Pass user throught
                    //  .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(user -> runOnUiThread(() -> { Log.v(TAG, "Hello") }), throwable -> { });

    I'm using Jack and the latest AndroidStudio Gradle plugin (2.2.2) I've attached my proguard file in case you want to have a look: proguard-rules.txt

    opened by supercairos 22
  • Reverted some View and Widget Observables to use simple objects instead of Event objects

    Reverted some View and Widget Observables to use simple objects instead of Event objects

    Recent changes to UI observables (particularly, 406bf6840fff2a98316faec8702311f9322047aa) added number of POJO event classes as well as some of associated infrastructure. Some of those were really useful, but few others: click, text change and toggle (aka "input") event classes look forced, as if those were added solely to match style of similar methods. Unfortunately, as explained below, they aren't very useful and accomplish nothing, except adding redundant entities and increasing range of possible issues.

    Few possible uses for event classes, that come to mind are:

    1. Encapsulating state, not stored in event source itself. This is the only sensible use for event classes in Android, which is why OnItemClickEven and OnListViewScrollEvent are legitimately useful and were added for good reason. Clearly not the case for click, text change and CompoundButton toggle events.
    2. Storing associated data, for example for doing reduce on it. None of the event classes in question (except OnSubscribeTextViewInput) contain any useful state. Click and compound button switch are self-descriptive. CharSequence, returned by TextView.getText(), can be mutable, and as such, is dangerous to use, unless immediately converted to string (which means, that at least one map call have to be done anyway).
    3. Turning emission of same object into emission of multiple distinct objects. RxJava already have timestamp operator for this.
    4. Passing those events somewhere else, possibly after serializing them. Doing so with all 3 events in question is pointless and even potentially dangerous. All of them contain little besides strong reference to event source, which makes them potential source of memory leaks, and makes it harder to write Rx plugins, detecting those.

    This merge request adds back Observables with tests and corresponding static methods, emitting plain View, TextView and Boolean objects. It also deprecates event-based methods. While we are at it, I have also renamed "input" to "toggle" as original naming choice was just plain bad.

    opened by Alexander-- 21
  • Added reactive versions of Activities and Fragments

    Added reactive versions of Activities and Fragments

    Subclasses of the common Activity and Fragment classes, extended so you can easily get an Observable<LifecycleEvent>.

    I wanted to get the ball rolling on this discussion (since it's the second part of #12, as I viewed it). I am fully aware this may be a controversial move. :P

    I tried working up a version using ActivityLifecycleCallbacks, but it felt too weird to have one solution for Activity and another for Fragment. Also, watching #84 has caused me to realize there are multiple places where being able to hook into the Activity or Fragment directly will save a lot of boilerplate.

    I purposefully chose to not rename the subclasses. That way, when you extend, say, Activity the package resolution dialog will show this version as well.

    One conspicuously missing extension is ActionBarActivity, since it depends on #83.

    opened by dlew 21
  • CompositeException Behavior

    CompositeException Behavior

    There are possibly improvements that need to be made specific to Android related to CompositeException.

    History of the discussion and work on this can be found at https://github.com/ReactiveX/RxJava/issues/1405

    opened by benjchristensen 21
  • Proposal/rehash: Use async Messaging

    Proposal/rehash: Use async Messaging

    This PR changes the default main thread Handler to use asynchronous messaging. This allows us to avoid VSYNC locking that otherwise pushes every post to the next frame.

    This works by relying on the new Handler.createAsync factory in API 28, and on pre-28 it will reflectively fall back to a private constructor of Handler (that's always existed) to enable this.

    This should give us the original goal of #228 with the safety of still leaning on the main thread looper and not trying to directly run things ourselves and risking deadlocks/trampolining issues.

    To use SDK 28, updated the AGP plugin and gradle along the way.

    Prior discussion below

    ~This is a main thread scheduler that's optimized to directly execute given Runnables if it's already on the main thread, rather than always scheduling.~

    ~Prior art: #228~

    ~Kept as a standalone implementation right now for review and discussion, but ideally this implementation would replace the existing main thread scheduler implementation as the default.~

    opened by ZacSweers 20
  • Can't use AndroidSchedulers.mainThread() after migrating to RxJava2?

    Can't use AndroidSchedulers.mainThread() after migrating to RxJava2?

    After migrating to RxJava2. observeOn doesn't accept AndroidSchedulers. Is there a alternate in Schedulers for AndroidSchedulers.mainThread() or how should i solve this issue ?

    OLD versions RxAndroid - 1.2.1 RxJava - 1.1.6

    Migrated Versions RxAndroid - 2.0.1 RxJava - 2.0.3

                    .subscribe(new SingleSubscriber<List<Items>>() {
                        public void onSuccess(List<Items> products) {
                            if (!products.isEmpty()) {
                            } else {
                        public void onError(Throwable error) {
                            Timber.e(error, "There was an error retrieving the products");
    opened by AruLNadhaN 18
  • java.lang.NoSuchMethodError


    OkHttp Dispatcher(48197)


    No static method disposed()Lio/reactivex/rxjava3/disposables/Disposable; in class Lio/reactivex/rxjava3/disposables/Disposable; or its super classes (declaration of 'io.reactivex.rxjava3.disposables.Disposable' appears in base.apk!classes3.dex)

    1 io.reactivex.rxjava3.android.schedulers.HandlerScheduler$HandlerWorker.schedule(HandlerScheduler.java:91)

    2 io.reactivex.rxjava3.core.Scheduler$Worker.schedule(Scheduler.java:402) 3 io.reactivex.rxjava3.internal.operators.observable.ObservableObserveOn$ObserveOnObserver.schedule(ObservableObserveOn.java:161) 4 io.reactivex.rxjava3.internal.operators.observable.ObservableObserveOn$ObserveOnObserver.onComplete(ObservableObserveOn.java:139) 5 io.reactivex.rxjava3.internal.operators.observable.ObservableSubscribeOn$SubscribeOnObserver.onComplete(ObservableSubscribeOn.java:68) 6 retrofit2.adapter.rxjava3.BodyObservable$BodyObserver.onComplete(BodyObservable.java:70) 7 retrofit2.adapter.rxjava3.CallEnqueueObservable$CallCallback.onResponse(CallEnqueueObservable.java:66) 8 retrofit2.OkHttpCall$1.onResponse(OkHttpCall.java:161) 9 okhttp3.RealCall$AsyncCall.run(RealCall.kt:138) 10 java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167) 11 java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641) 12 java.lang.Thread.run(Thread.java:929)

    What is the problem and how to solve it ?

    opened by 13man 20
  • 3.0.2(Nov 9, 2022)


    • Ensure the main scheduler can be replaced in unit tests without needing Robolectric.


    implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'
    Source code(tar.gz)
    Source code(zip)
  • 3.0.1(Nov 9, 2022)


    • AndroidSchedulers.mainThread() now correctly checks whether async messages are supported by the current Android version. Previously it always assumed they were available (true on API 16+).


    • Update to RxJava 3.1.5. This includes a transitive dependency bump to Reactive-Streams 1.0.4 which re-licenses that dependency from CC-0 to MIT-0.


    implementation 'io.reactivex.rxjava3:rxandroid:3.0.1'
    Source code(tar.gz)
    Source code(zip)
  • 3.0.0(Feb 14, 2020)

    General availability of RxAndroid 3.0 for use with RxJava 3.0!

    The Maven groupId has changed to io.reactivex.rxjava3 and the package is now io.reactivex.rxjava3.android.

    The APIs and behavior of RxAndroid 3.0.0 is otherwise exactly the same as RxAndroid 2.1.1 with one notable exception:

    Schedulers created via AndroidSchedulers.from now deliver async messages by default. This is also true for AndroidSchedulers.mainThread().

    For more information about RxJava 3.0 see its release notes.


    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
    Source code(tar.gz)
    Source code(zip)
  • 2.1.1(Feb 15, 2019)

  • 2.1.0(Aug 16, 2018)

  • 2.0.2(Feb 12, 2018)

  • 2.0.1(Nov 12, 2016)

  • 2.0.0(Oct 29, 2016)

    General availability of RxAndroid 2.0 for use with RxJava 2.0!

    The sections below contain the changes since 2.0.0-RC1.

    API Enhancements

    • Pull 338 - Evaluate Schedulers initialization via Callable
    Source code(tar.gz)
    Source code(zip)
  • 2.0.0-RC1(Aug 25, 2016)

    RxAndroid 2.0 has been rewritten from scratch to support RxJava 2.0.

    The library still offers the same APIs: a scheduler and stream cancelation callback that know about the main thread, a means of creating a scheduler from any Looper, and plugin support for the main thread sheduler. They just reside in a new package, io.reactivex.android, and may have slightly different names.

    For more information about RxJava 2.0 see its RC1 release notes


    compile 'io.reactivex.rxjava2:rxandroid:2.0.0-RC1'
    Source code(tar.gz)
    Source code(zip)
  • 1.2.1(Aug 25, 2016)

    • New: AndroidSchedulers.reset() allows clearing the scheduler cache such that the next call to AndroidSchedulers.mainThread() will ask the RxAndroidSchedulerHook to re-create it. This API is experimental to match Schedulers.reset() in RxJava.
    • RxJava dependency now points at v1.1.6.
    Source code(tar.gz)
    Source code(zip)
  • 1.2.0(May 4, 2016)

    • Rewrite the Android-specific schedulers (main thread or custom) to greatly reduce allocation and performance overhead of scheduling work.
    • HandlerScheduler.create has been deprecated in favor of AndroidSchedulers.from(Looper) as a Looper is the actual mechanism of scheduling on Android, not Handler.
    • Fix: Correct the behavior of AndroidSchedulers.mainThread() to only invoke the registered RxAndroidSchedulersHook for creating the main thread scheduler and to cache the result instead of invoking it every time. This behvior change eliminates a performance overhead and brings behavior in line with RxJava. If you were relying on the ability to change the main thread scheduler over time (such as for tests), return a delegating scheduler from the hook which allows changing the delegate instance at will.
    • RxJava dependency now points at v1.1.4.
    • RxAndroidPlugins.reset() is now marked as @Experimental to match the RxJava method of the same name and behavior.
    Source code(tar.gz)
    Source code(zip)
  • 1.1.0(Dec 9, 2015)

    • New: MainThreadSubscription utility class runs its onUnsubscribe action on the Android main thread. This aids in adding tear-down actions which must be executed on the main thread without having to deal with posting to the main thread yourself.
    • Fix: Lazily initialize mainThread() scheduler so that no Android code is run when overridden. This allows unit tests overriding the implementation to work correctly.
    • RxJava dependency now points at v1.1.0.


    compile 'io.reactivex:rxandroid:1.1.0'
    Source code(tar.gz)
    Source code(zip)
  • 1.0.1(Aug 10, 2015)

    • Fix: Correctly check isUnsubscribed() state in HandlerScheduler's worker before scheduling more work.
    • Fix: Eliminate a potential race condition in HandlerScheduler to ensure any posted work will be canceled on unsubscription.


    compile 'io.reactivex:rxandroid:1.0.1'
    Source code(tar.gz)
    Source code(zip)
  • v1.0.0(Aug 5, 2015)

    Initial stable release!

    In order to provide a library that no project using RxJava would hesitate to depend on, the decision was made to remove the APIs which were not absolutely fundamental to all apps. That is what's contained in this release.

    Functionality which was previously part of this library is being explored in separate, modular libraries:

    • LifecycleObservable: https://github.com/trello/RxLifecycle
    • ViewObservable and WidgetObservable: https://github.com/JakeWharton/RxBinding

    This allows for a simpler process of design, development, and experimentation for the best ways to provide features like hooks into the lifecycle, binding to UI components, and simplifying interaction with all of Android's API. Not only can these projects now have their own release schedule, but it allows developers to pick and choose which ones are appropriate for your application.

    Applications using the various APIs which were previously in this library do not need to update immediately. Due to the number of APIs removed, switching to 1.0 and the use of these third-party libraries should be done gradually.

    Breaking changes:

    • AndroidSchedulers.handlerThread() is now HandlerScheduler.from().
    • All other APIs have been removed aside from AndroidSchedulers.mainThread(), RxAndroidPlugins, and RxAndroidSchedulersHook.


    compile 'io.reactivex:rxandroid:1.0.0'
    Source code(tar.gz)
    Source code(zip)
  • v0.25.0(Jun 29, 2015)

    • New: RxAndroidPlugins and its RxAndroidSchedulersHook provides a mechanism similar to RxJavaPlugins (and its RxJavaSchedulersHook) for changing the scheduler returned from AndroidSchedulers.mainThread() as well as a callback for each subscription on any Handler-based scheduler.
    • Fix: Ensure errors are properly propagated from ContentObservable.fromCursor.
    • Fix: LifecycleObservable now correctly unsubscribes from its sources.

    Breaking changes:

    • Users of AppObservable.bindFragment with a support-v4 Fragment should now use bindSupportFragment.
    Source code(tar.gz)
    Source code(zip)
  • v0.24.0(Jun 29, 2015)

    This release has some breaking changes:

    • rx.android.observables.AndroidObservable has changed to rx.android.app.AppObservable;
    • ViewObservable has moved from rx.android.observables to rx.android.view
    • (as part of RxJava's breaking changes) collect has changed
    Source code(tar.gz)
    Source code(zip)
  • v0.23.0(Dec 3, 2014)

  • v0.22.0(Oct 16, 2014)

    This release adds a number of new operators:

    • Add operator to monitor SharedPreference changes
    • Add view state event types to streamline ViewObservable
    • Add OperatorAdapterViewOnItemClick to observe OnItemClick events in AdapterViews
    Source code(tar.gz)
    Source code(zip)
  • v0.21.0(Oct 1, 2014)

    This is the first release after splitting from RxJava into its own top level project RxAndroid.

    This is the same code as version 0.20.4 except:

    • all deprecated methods and types are deleted
    • now published to groupId io.reactivex instead of com.netflix.rxjava
    • artifactId is now rxandroid instead of rxjava-android

    Issues and discussions specific to RxAndroid should now be had in the RxAndroid Issues. Issues with core Observable and operators remain in RxJava Issues.

    The artifacts can be found on maven Central at: http://repo1.maven.org/maven2/io/reactivex/rxandroid

    Artifacts: Maven Central

    Source code(tar.gz)
    Source code(zip)
  • 0.20.4(Oct 1, 2014)

Reactive Extensions for Async Programming
Materially inspired widgets and views that expose RxJava bindings.

Rx.Widgets Materially inspired widgets and views. Use ExpandableButtonGroup Add the widget to your view: <io.andref.rx.widgets.ExpandableButtonGro

Andrefio 12 Mar 12, 2018
Xamarin.Android provides open-source bindings of the Android SDK for use with .NET managed languages such as C#

Xamarin.Android Xamarin.Android provides open-source bindings of the Android SDK for use with .NET managed languages such as C#. Build Status Platform

Xamarin 1.8k Jan 5, 2023
Okuki is a simple, hierarchical navigation bus and back stack for Android, with optional Rx bindings, and Toothpick DI integration.

Okuki A simple, hierarchical navigation bus and back stack for Android, with optional Rx bindings, and Toothpick integration for automatic dependency-

Cain Wong 143 Nov 25, 2022
Bindings to the JNI library on Android for Kotlin/Native

JNI Utils using this library: implementation("io.github.landrynorris:jni-utils:0.0.1-alpha01") This library provides bindings to the JNI library on An

Landry Norris 6 Sep 27, 2022
Kotlin MPP bindings for various clis

kommander Kotlin MPP bindings for various cli tools. The libraries only wrap around the clis and still require them to be natively available on the PA

Martynas Petuška 3 Mar 18, 2022
Small Kafka Playground to play around with Test Containers, and KotlinX Coroutines bindings while reading Kafka Definite Guide V2

KafkaPlayground Small playground where I'm playing around with Kafka in Kotlin and the Kafka SDK whilst reading the Kafka book Definite Guide from Con

Simon Vergauwen 34 Dec 30, 2022
Kafka bindings for Kotlin `suspend`, and Kafka streaming operators for KotlinX Flow.

Module kotlin-kafka Rationale Goals Example This project is still under development, andd started as a playground where I was playing around with Kafk

Simon Vergauwen 34 Dec 30, 2022
This little project provides Kotlin bindings for the popular tree-sitter library

kotlintree This little project provides Kotlin bindings for the popular tree-sitter library. Currently it only supports the Kotlin JVM target, but Kot

Christian Banse 23 Nov 28, 2022
Java bindings for Skia

Skija: Java bindings for Skia Skia is an open source 2D graphics library which provides common APIs that work across a variety of hardware and softwar

JetBrains 2.5k Dec 31, 2022
Movie Android App written in Kotlin, MVVM, RxJava, Coroutine (Upcoming), Android Architecture Components and Jetpack Compose (Upcoming).

MovieHunt MovieHunt is a sample Android project using The Movie DB API based on MVVM architecture. It showcases the latest Android tech stacks with we

Engine Bai 596 Dec 31, 2022
Android Viper template with Kotlin, Dagger 2, Retrofit & RxJava

Android VIPER Architecture Example This repository contains a detailed sample client-server app that implements VIPER(View-Interactor-Presenter-Entity

OmiSoft 33 Nov 4, 2022
Learning RxJava for Android by example

Learning RxJava for Android by example This is a repository with real-world useful examples of using RxJava with Android. It usually will be in a cons

Kaushik Gopal 7.6k Dec 30, 2022
RxJava architecture library for Android

Reference Architecture for Android using RxJava This is an ambitious reference project of what can be done with RxJava to create an app based on strea

Reark 2.1k Dec 17, 2022
malik dawar 87 Sep 18, 2022
Observe Android's CONNECTIVITY_CHANGE broadcasts using RxJava.

Rx.Network Listen for Android's CONNECTIVITY_CHANGE broadcasts. Use Add the ACCESS_NEWORK_STATE permission to AndroidManifest.xml <uses-permission

Andrefio 23 Jul 7, 2022
RxJava binding APIs for Android's UI widgets.

RxBinding RxJava binding APIs for Android UI widgets from the platform and support libraries. Download Platform bindings: implementation 'com.jakewhar

Jake Wharton 9.7k Jan 6, 2023
Dead simple EventBus for Android made with Kotlin and RxJava 2

KBus Super lightweight (13 LOC) and minimalistic (post(), subscribe(), unsubscribe()) EventBus written with idiomatic Kotlin and RxJava 2 KBus in 3 st

Adriel Café 46 Dec 6, 2022
Showcase project of Functional Reactive Programming on Android, using RxJava.

FunctionalAndroidReference FunctionalAndroidReference is a showcase project of Functional Reactive Programming on Android, using RxJava. It's a compan

Paco 278 Nov 18, 2022
Learning RxJava for Android by example

Learning RxJava for Android by example This is a repository with real-world useful examples of using RxJava with Android. It usually will be in a cons

Kaushik Gopal 7.6k Jan 5, 2023
RxJava architecture library for Android

Reference Architecture for Android using RxJava This is an ambitious reference project of what can be done with RxJava to create an app based on strea

Reark 2.1k Dec 17, 2022