Added LifecycleTransformer for access to Single Transformers

trello-archive · May 5, 2016 · 32d09f4 · 32d09f4
1 parent be808eb
commit 32d09f4
Show file tree

Hide file tree

Showing 9 changed files with 267 additions and 26 deletions.
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/LifecycleTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/LifecycleTransformer.java
@@ -0,0 +1,10 @@
+package com.trello.rxlifecycle;
+
+import rx.Observable;
+import rx.Single;
+
+public interface LifecycleTransformer<T> extends Observable.Transformer<T, T> {
+
+    Single.Transformer<T, T> forSingle();
+
+}
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/RxLifecycle.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/RxLifecycle.java
@@ -37,7 +37,7 @@ private RxLifecycle() {
     @Deprecated
     @NonNull
     @CheckResult
-    public static <T> Observable.Transformer<T, T> bindUntilFragmentEvent(
+    public static <T> LifecycleTransformer<T> bindUntilFragmentEvent(
         @NonNull final Observable<FragmentEvent> lifecycle, @NonNull final FragmentEvent event) {
         return bindUntilEvent(lifecycle, event);
     }
@@ -50,7 +50,7 @@ public static <T> Observable.Transformer<T, T> bindUntilFragmentEvent(
     @Deprecated
     @NonNull
     @CheckResult
-    public static <T> Observable.Transformer<T, T> bindUntilActivityEvent(
+    public static <T> LifecycleTransformer<T> bindUntilActivityEvent(
         @NonNull final Observable<ActivityEvent> lifecycle, @NonNull final ActivityEvent event) {
         return bindUntilEvent(lifecycle, event);
     }
@@ -69,8 +69,8 @@ public static <T> Observable.Transformer<T, T> bindUntilActivityEvent(
      */
     @NonNull
     @CheckResult
-    public static <T, R> Observable.Transformer<T, T> bindUntilEvent(@NonNull final Observable<R> lifecycle,
-                                                                     @NonNull final R event) {
+    public static <T, R> LifecycleTransformer<T> bindUntilEvent(@NonNull final Observable<R> lifecycle,
+                                                                @NonNull final R event) {
         checkNotNull(lifecycle, "lifecycle == null");
         checkNotNull(event, "event == null");
 
@@ -97,7 +97,7 @@ public static <T, R> Observable.Transformer<T, T> bindUntilEvent(@NonNull final
      */
     @NonNull
     @CheckResult
-    public static <T> Observable.Transformer<T, T> bindActivity(@NonNull final Observable<ActivityEvent> lifecycle) {
+    public static <T> LifecycleTransformer<T> bindActivity(@NonNull final Observable<ActivityEvent> lifecycle) {
         return bind(lifecycle, ACTIVITY_LIFECYCLE);
     }
 
@@ -121,7 +121,7 @@ public static <T> Observable.Transformer<T, T> bindActivity(@NonNull final Obser
      */
     @NonNull
     @CheckResult
-    public static <T> Observable.Transformer<T, T> bindFragment(@NonNull final Observable<FragmentEvent> lifecycle) {
+    public static <T> LifecycleTransformer<T> bindFragment(@NonNull final Observable<FragmentEvent> lifecycle) {
         return bind(lifecycle, FRAGMENT_LIFECYCLE);
     }
 
@@ -141,7 +141,7 @@ public static <T> Observable.Transformer<T, T> bindFragment(@NonNull final Obser
      */
     @NonNull
     @CheckResult
-    public static <T> Observable.Transformer<T, T> bindView(@NonNull final View view) {
+    public static <T> LifecycleTransformer<T> bindView(@NonNull final View view) {
         checkNotNull(view, "view == null");
 
         return bind(RxView.detaches(view));
@@ -155,7 +155,7 @@ public static <T> Observable.Transformer<T, T> bindView(@NonNull final View view
     @Deprecated
     @NonNull
     @CheckResult
-    public static <T, E> Observable.Transformer<T, T> bindView(@NonNull final Observable<? extends E> lifecycle) {
+    public static <T, E> LifecycleTransformer<T> bindView(@NonNull final Observable<? extends E> lifecycle) {
         return bind(lifecycle);
     }
 
@@ -174,7 +174,7 @@ public static <T, E> Observable.Transformer<T, T> bindView(@NonNull final Observ
      */
     @NonNull
     @CheckResult
-    public static <T, R> Observable.Transformer<T, T> bind(@NonNull final Observable<R> lifecycle) {
+    public static <T, R> LifecycleTransformer<T> bind(@NonNull final Observable<R> lifecycle) {
         checkNotNull(lifecycle, "lifecycle == null");
 
         return new UntilLifecycleObservableTransformer<>(lifecycle);
@@ -196,13 +196,13 @@ public static <T, R> Observable.Transformer<T, T> bind(@NonNull final Observable
      */
     @NonNull
     @CheckResult
-    public static <T, R> Observable.Transformer<T, T> bind(@NonNull Observable<R> lifecycle,
-                                                           @NonNull final Func1<R, R> correspondingEvents) {
+    public static <T, R> LifecycleTransformer<T> bind(@NonNull Observable<R> lifecycle,
+                                                      @NonNull final Func1<R, R> correspondingEvents) {
         checkNotNull(lifecycle, "lifecycle == null");
         checkNotNull(correspondingEvents, "correspondingEvents == null");
 
         // Keep emitting from source until the corresponding event occurs in the lifecycle
-        return new UntilCorrespondingEventObservableTransformer<>(lifecycle, correspondingEvents);
+        return new UntilCorrespondingEventObservableTransformer<>(lifecycle.share(), correspondingEvents);
     }
 
     // Figures out which corresponding next lifecycle event in which to unsubscribe, for Activities

diff --git a/...le/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventObservableTransformer.java b/...le/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventObservableTransformer.java
@@ -1,6 +1,8 @@
 package com.trello.rxlifecycle;
 
+import android.support.annotation.NonNull;
 import rx.Observable;
+import rx.Single;
 import rx.functions.Func1;
 
 import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilCorrespondingEvent;
@@ -11,18 +13,51 @@
  * That lifecycle event is determined based on what stage we're at in
  * the current lifecycle.
  */
-class UntilCorrespondingEventObservableTransformer<T, R> implements Observable.Transformer<T, T> {
+final class UntilCorrespondingEventObservableTransformer<T, R> implements LifecycleTransformer<T> {
 
     final Observable<R> sharedLifecycle;
     final Func1<R, R> correspondingEvents;
 
-    public UntilCorrespondingEventObservableTransformer(Observable<R> lifecycle, Func1<R, R> correspondingEvents) {
-        this.sharedLifecycle = lifecycle.share(); // Share so that we always compare identical lifecycles
+    public UntilCorrespondingEventObservableTransformer(@NonNull Observable<R> sharedLifecycle,
+                                                        @NonNull Func1<R, R> correspondingEvents) {
+        this.sharedLifecycle = sharedLifecycle;
         this.correspondingEvents = correspondingEvents;
     }
 
     @Override
     public Observable<T> call(Observable<T> source) {
         return source.takeUntil(takeUntilCorrespondingEvent(sharedLifecycle, correspondingEvents));
     }
+
+    @Override
+    public Single.Transformer<T, T> forSingle() {
+        return new UntilCorrespondingEventSingleTransformer<>(sharedLifecycle, correspondingEvents);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+
+        UntilCorrespondingEventObservableTransformer<?, ?> that
+            = (UntilCorrespondingEventObservableTransformer<?, ?>) o;
+
+        if (!sharedLifecycle.equals(that.sharedLifecycle)) { return false; }
+        return correspondingEvents.equals(that.correspondingEvents);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = sharedLifecycle.hashCode();
+        result = 31 * result + correspondingEvents.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "UntilCorrespondingEventObservableTransformer{" +
+            "sharedLifecycle=" + sharedLifecycle +
+            ", correspondingEvents=" + correspondingEvents +
+            '}';
+    }
 }
diff --git a/...ecycle/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventSingleTransformer.java b/...ecycle/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventSingleTransformer.java
@@ -1,5 +1,6 @@
 package com.trello.rxlifecycle;
 
+import android.support.annotation.NonNull;
 import rx.Observable;
 import rx.Single;
 import rx.functions.Func1;
@@ -12,18 +13,45 @@
  * That lifecycle event is determined based on what stage we're at in
  * the current lifecycle.
  */
-class UntilCorrespondingEventSingleTransformer<T, R> implements Single.Transformer<T, T> {
+final class UntilCorrespondingEventSingleTransformer<T, R> implements Single.Transformer<T, T> {
 
     final Observable<R> sharedLifecycle;
     final Func1<R, R> correspondingEvents;
 
-    public UntilCorrespondingEventSingleTransformer(Observable<R> lifecycle, Func1<R, R> correspondingEvents) {
-        this.sharedLifecycle = lifecycle.share(); // Share so that we always compare identical lifecycles
+    public UntilCorrespondingEventSingleTransformer(@NonNull Observable<R> sharedLifecycle,
+                                                    @NonNull Func1<R, R> correspondingEvents) {
+        this.sharedLifecycle = sharedLifecycle;
         this.correspondingEvents = correspondingEvents;
     }
 
     @Override
     public Single<T> call(Single<T> source) {
         return source.takeUntil(takeUntilCorrespondingEvent(sharedLifecycle, correspondingEvents));
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+
+        UntilCorrespondingEventSingleTransformer<?, ?> that = (UntilCorrespondingEventSingleTransformer<?, ?>) o;
+
+        if (!sharedLifecycle.equals(that.sharedLifecycle)) { return false; }
+        return correspondingEvents.equals(that.correspondingEvents);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = sharedLifecycle.hashCode();
+        result = 31 * result + correspondingEvents.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "UntilCorrespondingEventSingleTransformer{" +
+            "sharedLifecycle=" + sharedLifecycle +
+            ", correspondingEvents=" + correspondingEvents +
+            '}';
+    }
 }
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventObservableTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventObservableTransformer.java
@@ -1,18 +1,20 @@
 package com.trello.rxlifecycle;
 
+import android.support.annotation.NonNull;
 import rx.Observable;
+import rx.Single;
 
 import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilEvent;
 
 /**
  * Continues a subscription until it sees a particular lifecycle event.
  */
-class UntilEventObservableTransformer<T, R> implements Observable.Transformer<T, T> {
+final class UntilEventObservableTransformer<T, R> implements LifecycleTransformer<T> {
 
     final Observable<R> lifecycle;
     final R event;
 
-    public UntilEventObservableTransformer(Observable<R> lifecycle, R event) {
+    public UntilEventObservableTransformer(@NonNull Observable<R> lifecycle, @NonNull R event) {
         this.lifecycle = lifecycle;
         this.event = event;
     }
@@ -21,4 +23,35 @@ public UntilEventObservableTransformer(Observable<R> lifecycle, R event) {
     public Observable<T> call(Observable<T> source) {
         return source.takeUntil(takeUntilEvent(lifecycle, event));
     }
+
+    @Override
+    public Single.Transformer<T, T> forSingle() {
+        return new UntilEventSingleTransformer<>(lifecycle, event);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+
+        UntilEventObservableTransformer<?, ?> that = (UntilEventObservableTransformer<?, ?>) o;
+
+        if (!lifecycle.equals(that.lifecycle)) { return false; }
+        return event.equals(that.event);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = lifecycle.hashCode();
+        result = 31 * result + event.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "UntilEventObservableTransformer{" +
+            "lifecycle=" + lifecycle +
+            ", event=" + event +
+            '}';
+    }
 }
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventSingleTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventSingleTransformer.java
@@ -1,5 +1,6 @@
 package com.trello.rxlifecycle;
 
+import android.support.annotation.NonNull;
 import rx.Observable;
 import rx.Single;
 
@@ -8,12 +9,12 @@
 /**
  * Continues a subscription until it sees a particular lifecycle event.
  */
-class UntilEventSingleTransformer<T, R> implements Single.Transformer<T, T> {
+final class UntilEventSingleTransformer<T, R> implements Single.Transformer<T, T> {
 
     final Observable<R> lifecycle;
     final R event;
 
-    public UntilEventSingleTransformer(Observable<R> lifecycle, R event) {
+    public UntilEventSingleTransformer(@NonNull Observable<R> lifecycle, @NonNull R event) {
         this.lifecycle = lifecycle;
         this.event = event;
     }
@@ -22,4 +23,30 @@ public UntilEventSingleTransformer(Observable<R> lifecycle, R event) {
     public Single<T> call(Single<T> source) {
         return source.takeUntil(takeUntilEvent(lifecycle, event));
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+
+        UntilEventSingleTransformer<?, ?> that = (UntilEventSingleTransformer<?, ?>) o;
+
+        if (!lifecycle.equals(that.lifecycle)) { return false; }
+        return event.equals(that.event);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = lifecycle.hashCode();
+        result = 31 * result + event.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "UntilEventSingleTransformer{" +
+            "lifecycle=" + lifecycle +
+            ", event=" + event +
+            '}';
+    }
 }
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilLifecycleObservableTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilLifecycleObservableTransformer.java
@@ -1,20 +1,49 @@
 package com.trello.rxlifecycle;
 
+import android.support.annotation.NonNull;
 import rx.Observable;
+import rx.Single;
 
 /**
  * Continues a subscription until it sees *any* lifecycle event.
  */
-class UntilLifecycleObservableTransformer<T, R> implements Observable.Transformer<T, T> {
+final class UntilLifecycleObservableTransformer<T, R> implements LifecycleTransformer<T> {
 
     final Observable<R> lifecycle;
 
-    public UntilLifecycleObservableTransformer(Observable<R> lifecycle) {
+    public UntilLifecycleObservableTransformer(@NonNull Observable<R> lifecycle) {
         this.lifecycle = lifecycle;
     }
 
     @Override
     public Observable<T> call(Observable<T> source) {
         return source.takeUntil(lifecycle);
     }
+
+    @Override
+    public Single.Transformer<T, T> forSingle() {
+        return new UntilLifecycleSingleTransformer<>(lifecycle);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) { return true; }
+        if (o == null || getClass() != o.getClass()) { return false; }
+
+        UntilLifecycleObservableTransformer<?, ?> that = (UntilLifecycleObservableTransformer<?, ?>) o;
+
+        return lifecycle.equals(that.lifecycle);
+    }
+
+    @Override
+    public int hashCode() {
+        return lifecycle.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "UntilLifecycleObservableTransformer{" +
+            "lifecycle=" + lifecycle +
+            '}';
+    }
 }