Add additional extension methods for android-archcomponents

android/autodispose-android-archcomponents/src/main/java/com/uber/autodispose/android/lifecycle/KotlinExtensions.kt

@@ -20,9 +20,22 @@ package com.uber.autodispose.android.lifecycle
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.Lifecycle.Event
 import androidx.lifecycle.LifecycleOwner
+import com.uber.autodispose.AutoDispose
+import com.uber.autodispose.FlowableSubscribeProxy
+import com.uber.autodispose.ObservableSubscribeProxy
+import com.uber.autodispose.SingleSubscribeProxy
+import com.uber.autodispose.MaybeSubscribeProxy
+import com.uber.autodispose.CompletableSubscribeProxy
+import com.uber.autodispose.ParallelFlowableSubscribeProxy
 import com.uber.autodispose.ScopeProvider
 import com.uber.autodispose.lifecycle.CorrespondingEventsFunction
 import io.reactivex.annotations.CheckReturnValue
+import io.reactivex.parallel.ParallelFlowable
+import io.reactivex.Observable
+import io.reactivex.Flowable
+import io.reactivex.Maybe
+import io.reactivex.Single
+import io.reactivex.Completable
 
 /**
  * Extension that returns a [ScopeProvider] for this [LifecycleOwner].
@@ -77,3 +90,93 @@ inline fun Lifecycle.scope(
   boundaryResolver: CorrespondingEventsFunction<Event>
 ): ScopeProvider = AndroidLifecycleScopeProvider.from(
     this, boundaryResolver)
+
+/**
+ * Extension that proxies to [Flowable.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun <T> Flowable<T>.autoDisposable(lifecycleOwner: LifecycleOwner): FlowableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [Flowable.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun <T> Flowable<T>.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): FlowableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))
+
+/**
+ * Extension that proxies to [Observable.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun <T> Observable<T>.autoDisposable(lifecycleOwner: LifecycleOwner): ObservableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [Observable.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun <T> Observable<T>.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): ObservableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))
+
+/**
+ * Extension that proxies to [Single.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun <T> Single<T>.autoDisposable(lifecycleOwner: LifecycleOwner): SingleSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [Single.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun <T> Single<T>.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): SingleSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))
+
+/**
+ * Extension that proxies to [Maybe.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun <T> Maybe<T>.autoDisposable(lifecycleOwner: LifecycleOwner): MaybeSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [Maybe.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun <T> Maybe<T>.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): MaybeSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))
+
+/**
+ * Extension that proxies to [Completable.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun Completable.autoDisposable(lifecycleOwner: LifecycleOwner): CompletableSubscribeProxy =
+    this.`as`(AutoDispose.autoDisposable<Any>(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [Completable.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun Completable.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): CompletableSubscribeProxy =
+    this.`as`(AutoDispose.autoDisposable<Any>(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))
+
+/**
+ * Extension that proxies to [ParallelFlowable.as] + [AutoDispose.autoDisposable]
+ */
+@CheckReturnValue
+inline fun <T> ParallelFlowable<T>.autoDisposable(lifecycleOwner: LifecycleOwner): ParallelFlowableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner)))
+
+/**
+ * Extension that proxies to [ParallelFlowable.as] + [AutoDispose.autoDisposable] and takes an [untilEvent] when
+ * subscription will be disposed.
+ */
+@CheckReturnValue
+inline fun <T> ParallelFlowable<T>.autoDisposable(lifecycleOwner: LifecycleOwner, untilEvent: Event): ParallelFlowableSubscribeProxy<T> =
+    this.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(lifecycleOwner, untilEvent)))

sample/build.gradle

@@ -100,4 +100,6 @@ dependencies {
   def leakcanaryVersion = '1.6.2'
   debugImplementation "com.squareup.leakcanary:leakcanary-android:$leakcanaryVersion"
   releaseImplementation "com.squareup.leakcanary:leakcanary-android-no-op:$leakcanaryVersion"
+
+  androidTestImplementation project(':test-utils')
 }

sample/src/androidTest/java/com/uber/autodispose/TestKotlinActivity.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2019. Uber Technologies
+ *
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.uber.autodispose
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import com.uber.autodispose.android.lifecycle.AndroidLifecycleScopeProvider
+import com.uber.autodispose.android.lifecycle.autoDisposable
+import com.uber.autodispose.android.lifecycle.scope
+import io.reactivex.Observable
+import java.util.concurrent.TimeUnit
+
+/**
+ * Test Activity class to verify compilation of various extension functions.
+ */
+class TestKotlinActivity : AppCompatActivity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // With extension function that overloads LifecycleOwner
+    Observable.interval(1, TimeUnit.SECONDS)
+        .autoDisposable(this)
+        .subscribe()
+
+    // With extension function that overloads LifecycleOwner and until Event
+    Observable.interval(1, TimeUnit.SECONDS)
+        .autoDisposable(this, Lifecycle.Event.ON_DESTROY)
+        .subscribe()
+
+    // With extension function that overloads ScopeProvider
+    Observable.interval(1, TimeUnit.SECONDS)
+        .autoDisposable(scope(Lifecycle.Event.ON_DESTROY))
+        .subscribe()
+
+    // With no extension function
+    Observable.interval(1, TimeUnit.SECONDS)
+        .autoDisposable(AndroidLifecycleScopeProvider.from(this))
+        .subscribe()
+  }
+}