.gitignore

@@ -68,4 +68,3 @@ local.properties
 
 # jEnv
 .java-version
-

.travis.yml

@@ -5,8 +5,10 @@ jdk:
 
 android:
   components:
+    - tools
+    - platform-tools
     - android-23
-    - build-tools-23.0.1
+    - build-tools-23.0.3
 
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 sudo: false

CHANGES.md

@@ -1,10 +1,29 @@
 # RxAndroid Releases #
 
+### Version 1.2.0 - May 4th 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.
+
+
 ### Version 1.1.0 - December 9th 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.
 
 

CONTRIBUTING.md

@@ -17,9 +17,9 @@ If you are adding a new file it should have a header like this:
  * 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
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

README.md

@@ -4,7 +4,7 @@ Android specific bindings for [RxJava](http://github.com/ReactiveX/RxJava).
 
 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 UI thread or any given `Handler`.
+the main thread or any given `Looper`.
 
 
 ## Communication
@@ -20,10 +20,10 @@ Since RxAndroid is part of the RxJava family the communication channels are simi
 # Binaries
 
 ```groovy
-compile 'io.reactivex:rxandroid:1.1.0'
+compile 'io.reactivex:rxandroid:1.2.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.
-compile 'io.reactivex:rxjava:1.1.0'
+compile 'io.reactivex:rxjava:1.1.4'
 ```
 
 * RxAndroid: <a href='http://search.maven.org/#search%7Cga%7C1%7Crxandroid'><img src='http://img.shields.io/maven-central/v/io.reactivex/rxandroid.svg'></a>
@@ -52,56 +52,41 @@ Futher details on building can be found on the RxJava [Getting Started][start] p
 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 UI thread
+## 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 UI 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:
+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:
 
 ```java
-public class ReactiveFragment extends Fragment {
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        Observable.just("one", "two", "three", "four", "five")
-                .subscribeOn(Schedulers.newThread())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(/* an Observer */);
-    }
+Observable.just("one", "two", "three", "four", "five")
+        .subscribeOn(Schedulers.newThread())
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(/* an Observer */);
 ```
 
-This will execute the Observable on a new thread, and emit results through `onNext` on the main UI thread.
+This will execute the `Observable` on a new thread, and emit results through `onNext` on the main thread.
 
-## Observing on arbitrary threads
-The previous sample is merely a specialization of a more general concept, namely binding asynchronous
-communication to an Android message loop using the `Handler` class. In order to observe an `Observable`
-on an arbitrary thread, create a `Handler` bound to that thread and use the `HandlerScheduler.from`
-scheduler:
+## 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`:
 
 ```java
-new Thread(new Runnable() {
-    @Override
-    public void run() {
-        final Handler handler = new Handler(); // bound to this thread
-        Observable.just("one", "two", "three", "four", "five")
-                .subscribeOn(Schedulers.newThread())
-                .observeOn(HandlerScheduler.from(handler))
-                .subscribe(/* an Observer */)
-
-        // perform work, ...
-    }
-}, "custom-thread-1").start();
+Looper backgroundLooper = // ...
+Observable.just("one", "two", "three", "four", "five")
+        .observeOn(AndroidSchedulers.from(backgroundLooper))
+        .subscribe(/* an Observer */)
 ```
 
-This will execute the Observable on a new thread and emit results through `onNext` on "custom-thread-1".
-(This example is contrived since you could as well call `observeOn(Schedulers.currentThread())` but it
-shall suffice to illustrate the idea.)
+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][issues].
+For bugs, feature requests, and discussion please use [GitHub Issues][issues].
 For general usage questions please use the [mailing list][list] or [StackOverflow][so].
 
 

RELEASING.md

@@ -0,0 +1,19 @@
+Release Process
+===============
+
+ 1.  Ensure `VERSION_NAME` in `gradle.properties` is set to the version you want to release.
+ 2.  Add an entry in `CHANGELOG.md` with the changes for the release.
+ 3.  Update `README.md` with the version about to be released. Also update the RxJava version in
+     this file to its latest.
+ 4.  Update the RxJava version in `rxandroid/build.gradle` to its latest. (We tell people that we
+     won't be tracking RxJava releases, and we don't, but we do it anyway when we are releasing for
+     those who ignore the advice.)
+ 5.  Commit: `git commit -am "Prepare version X.Y.X"`
+ 6.  Tag: `git tag -a X.Y.Z -m "Version X.Y.Z"`
+ 7.  Update `VERSION_NAME` in `gradle.properties` to the next development version. For example, if
+     you just tagged version 1.0.4 you would set this value to 1.0.5. Do NOT append "-SNAPSHOT" to
+     this value, it will be added automatically.
+ 8.  Commit: `git commit -am "Prepare next development version."`
+ 9.  Push: `git push && git push --tags`
+ 10. Paste the `CHANGELOG.md` contents for this version into a Release on GitHub along with the
+     Groovy for depending on the new version (https://github.com/ReactiveX/RxAndroid/releases).

build.gradle

@@ -3,20 +3,15 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:1.3.1'
+        classpath 'com.android.tools.build:gradle:2.1.0'
     }
 }
 
 ext {
     minSdkVersion = 9
     compileSdkVersion = 23
-    buildToolsVersion = '23.0.1'
+    buildToolsVersion = '23.0.3'
     sourceCompatibility = JavaVersion.VERSION_1_7
 }
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.8'
-    distributionUrl = 'https://services.gradle.org/distributions/gradle-2.8-all.zip'
-}
-
 apply plugin: 'android-reporting'

gradle.properties

@@ -1,5 +1,5 @@
 GROUP=io.reactivex
-VERSION_NAME=1.1.0
+VERSION_NAME=1.2.0
 POM_NAME=RxAndroid
 POM_PACKAGING=aar
 POM_DESCRIPTION=RxAndroid

gradle/artifacts.gradle

@@ -24,6 +24,10 @@ if (project.plugins.hasPlugin('com.android.library')) {
 
             // Output to a unique javadoc folder per variant
             destinationDir = new File(project.docsDir, "javadoc-$variant.name")
+
+            if (JavaVersion.current().isJava8Compatible()) {
+                options.addStringOption('Xdoclint:none', '-quiet')
+            }
         }
 
         // For official releasese, don't prefix the name so the artifact is published correctly
@@ -47,7 +51,7 @@ if (project.plugins.hasPlugin('com.android.library')) {
         }
 
         if (variant.name == 'release') {
-            // There's a lot of "magic" around the archives configuration; easier 
+            // There's a lot of "magic" around the archives configuration; easier
             // just to embrace it rather than try to configure around it
             artifacts {
                 archives javadocJarTask, sourcesJarTask
@@ -61,4 +65,4 @@ if (project.plugins.hasPlugin('com.android.library')) {
             artifacts.add configurationName, sourcesJarTask
         }
     }
-}
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Sat Oct 31 12:01:47 CET 2015
+#Mon May 02 08:26:04 CDT 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.8-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-all.zip

gradlew

@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,26 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -85,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,7 +46,7 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
 if "%@eval[2+2]" == "4" goto 4NT_args

rxandroid/build.gradle

@@ -47,7 +47,7 @@ repositories {
 }
 
 dependencies {
-    compile 'io.reactivex:rxjava:1.1.0'
+    compile 'io.reactivex:rxjava:1.1.4'
 
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.10.19'

rxandroid/src/main/java/rx/android/MainThreadSubscription.java

@@ -30,19 +30,19 @@
  * A {@link #verifyMainThread() convenience method} is also provided for validating whether code
  * is being called on the main thread. Calls to this method along with instances of this class are
  * commonly used when creating custom observables using the following pattern:
- * <pre>{@code
+ * <pre><code>
  * &#064;Override public void call(Subscriber<? extends T> subscriber) {
  *   MainThreadSubscription.verifyMainThread();
  *
  *   // TODO set up behavior
  *
- *   subscriber.add(new MainThreadSubscriber() {
+ *   subscriber.add(new MainThreadSubscription() {
  *     &#064;Override public void onUnsubscribe() {
  *       // TODO undo behavior
  *     }
  *   });
  * }
- * }</pre>
+ * </code></pre>
  */
 public abstract class MainThreadSubscription implements Subscription {
   /**