Merge remote-tracking branch 'upstream/master'

Author: landonf

rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/AndroidObservable.java

@@ -15,26 +15,145 @@
  */
 package rx.android.observables;
 
+import static org.mockito.Mockito.verify;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
 import rx.Observable;
+import rx.Observer;
 import rx.operators.OperationObserveFromAndroidComponent;
 
 import android.app.Activity;
 import android.app.Fragment;
+import android.os.Build;
+import android.support.v4.app.FragmentActivity;
+
 
 public final class AndroidObservable {
 
+    private static final boolean USES_SUPPORT_FRAGMENTS;
+
+    static {
+        boolean supportFragmentsAvailable = false;
+        try {
+            Class.forName("android.support.v4.app.Fragment");
+            supportFragmentsAvailable = true;
+        } catch (ClassNotFoundException e) {
+        }
+        USES_SUPPORT_FRAGMENTS = supportFragmentsAvailable;
+    }
+
     private AndroidObservable() {}
 
+    /**
+     * Transforms a source observable to be attached to the given Activity, in such a way that notifications will always
+     * arrive on the main UI thread. Currently, this is equivalent to calling <code>observeOn(AndroidSchedulers.mainThread())</code>,
+     * but this behavior may change in the future, so it is encouraged to use this wrapper instead.
+     * <p/>
+     * You must unsubscribe from the returned observable in <code>onDestroy</code> to not leak the given Activity.
+     * <p/>
+     * Ex.:
+     * <pre>
+     *     // in any Activity
+     *     mSubscription = fromActivity(this, Observable.just("value")).subscribe(...);
+     *     // in onDestroy
+     *     mSubscription.unsubscribe();
+     * </pre>
+     *
+     * @param activity         the activity in which the source observable will be observed
+     * @param sourceObservable the observable sequence to observe from the given Activity
+     * @param <T>
+     * @return a new observable sequence that will emit notifications on the main UI thread
+     */
     public static <T> Observable<T> fromActivity(Activity activity, Observable<T> sourceObservable) {
         return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, activity);
     }
 
-    public static <T> Observable<T> fromFragment(Fragment fragment, Observable<T> sourceObservable) {
-        return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, fragment);
+    /**
+     * Transforms a source observable to be attached to the given fragment, in such a way that notifications will always
+     * arrive on the main UI thread. Moreover, it will be guaranteed that no notifications will be delivered to the
+     * fragment while it's in detached state (i.e. its host Activity was destroyed.) In other words, during calls
+     * to onNext, you may assume that fragment.getActivity() will never return null.
+     * <p/>
+     * This method accepts both native fragments and support library fragments in its first parameter. It will throw
+     * for unsupported types.
+     * <p/>
+     * You must unsubscribe from the returned observable in <code>onDestroy</code> to not leak the given fragment.
+     * <p/>
+     * Ex.:
+     * <pre>
+     *     // in any Fragment
+     *     mSubscription = fromFragment(this, Observable.just("value")).subscribe(...);
+     *     // in onDestroy
+     *     mSubscription.unsubscribe();
+     * </pre>
+     *
+     * @param fragment         the fragment in which the source observable will be observed
+     * @param sourceObservable the observable sequence to observe from the given fragment
+     * @param <T>
+     * @return a new observable sequence that will emit notifications on the main UI thread
+     */
+    public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sourceObservable) {
+        if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
+            return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (android.support.v4.app.Fragment) fragment);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
+            return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (Fragment) fragment);
+        } else {
+            throw new IllegalArgumentException("Target fragment is neither a native nor support library Fragment");
+        }
     }
 
-    public static <T> Observable<T> fromFragment(android.support.v4.app.Fragment fragment, Observable<T> sourceObservable) {
-        return OperationObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, fragment);
+    @RunWith(RobolectricTestRunner.class)
+    @Config(manifest = Config.NONE)
+    public static final class AndroidObservableTest {
+
+        // support library fragments
+        private FragmentActivity fragmentActivity;
+        private android.support.v4.app.Fragment supportFragment;
+
+        // native fragments
+        private Activity activity;
+        private Fragment fragment;
+
+        @Mock
+        private Observer<String> observer;
+
+        @Before
+        public void setup() {
+            MockitoAnnotations.initMocks(this);
+            supportFragment = new android.support.v4.app.Fragment();
+            fragmentActivity = Robolectric.buildActivity(FragmentActivity.class).create().get();
+            fragmentActivity.getSupportFragmentManager().beginTransaction().add(supportFragment, null).commit();
+
+            fragment = new Fragment();
+            activity = Robolectric.buildActivity(Activity.class).create().get();
+            activity.getFragmentManager().beginTransaction().add(fragment, null).commit();
+        }
+
+        @Test
+        public void itSupportsFragmentsFromTheSupportV4Library() {
+            fromFragment(supportFragment, Observable.just("success")).subscribe(observer);
+            verify(observer).onNext("success");
+            verify(observer).onCompleted();
+        }
+
+        @Test
+        public void itSupportsNativeFragments() {
+            fromFragment(fragment, Observable.just("success")).subscribe(observer);
+            verify(observer).onNext("success");
+            verify(observer).onCompleted();
+        }
+
+        @Test(expected = IllegalArgumentException.class)
+        public void itThrowsIfObjectPassedIsNotAFragment() {
+            fromFragment("not a fragment", Observable.never());
+        }
     }
 
 }

rxjava-contrib/rxjava-string/build.gradle

@@ -0,0 +1,30 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    testCompile project(":rxjava-core").sourceSets.test.output 
+    provided 'junit:junit-dep:4.10'
+    provided 'org.mockito:mockito-core:1.8.5'
+}
+
+javadoc {
+    options {
+        doclet = "org.benjchristensen.doclet.DocletExclude"
+        docletpath = [rootProject.file('./gradle/doclet-exclude.jar')]
+        stylesheetFile = rootProject.file('./gradle/javadocStyleSheet.css')
+        windowTitle = "RxJava Javadoc ${project.version}"
+    }
+    options.addStringOption('top').value = '<h2 class="title" style="padding-top:40px">RxJava</h2>'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-string'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+    }
+}