Skip to content

Commit 03bcda9

Browse files
lfkellogglfkellogg
committed
WIP
1 parent e585921 commit 03bcda9

File tree

3 files changed

+118
-43
lines changed

3 files changed

+118
-43
lines changed

‎firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/FirebaseAppDistributionLifecycleNotifier.java

Lines changed: 110 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -23,14 +23,20 @@
2323
import androidx.annotation.VisibleForTesting;
2424
import com.google.android.gms.tasks.Task;
2525
import com.google.android.gms.tasks.TaskCompletionSource;
26+
import com.google.android.gms.tasks.Tasks;
2627
import java.util.ArrayDeque;
2728
import java.util.Queue;
2829

2930
class FirebaseAppDistributionLifecycleNotifier implements Application.ActivityLifecycleCallbacks {
3031

31-
/** A functional interface for a function that takes an activity and does something with it. */
32-
interface ActivityConsumer {
33-
void consume(Activity activity) throws FirebaseAppDistributionException;
32+
/** A functional interface for a function that takes an activity and returns a value. */
33+
interface ActivityFunction<T> {
34+
T apply(Activity activity) throws FirebaseAppDistributionException;
35+
}
36+
37+
/** A functional interface for a function that takes an activity and returns a {@link Task}. */
38+
interface ActivityChainingFunction<T> {
39+
Task<T> apply(Activity activity) throws FirebaseAppDistributionException;
3440
}
3541

3642
private static FirebaseAppDistributionLifecycleNotifier instance;
@@ -97,46 +103,115 @@ interface OnActivityDestroyedListener {
97103
* activity comes to the foreground.
98104
*/
99105
Task<Activity> getForegroundActivity() {
100-
return getForegroundActivity(activity -> {});
101-
}
102-
103-
/**
104-
* Get a {@link Task} that will succeed with a result of the app's foregrounded {@link Activity},
105-
* when one is available, after passing the activity to an {@link ActivityConsumer}.
106-
*
107-
* <p>The returned task will fail with a {@link FirebaseAppDistributionException} if the consumer
108-
* throws. Otherwise it will never fail, and will wait indefinitely for a foreground activity
109-
* before applying the consumer.
110-
*/
111-
Task<Activity> getForegroundActivity(ActivityConsumer consumer) {
112106
synchronized (lock) {
113-
TaskCompletionSource<Activity> task = new TaskCompletionSource<>();
114107
if (currentActivity != null) {
115-
consumeActivityAndCompleteTask(task, currentActivity, consumer);
116-
} else {
117-
addOnActivityResumedListener(
118-
new OnActivityResumedListener() {
119-
@Override
120-
public void onResumed(Activity activity) {
121-
consumeActivityAndCompleteTask(task, activity, consumer);
122-
removeOnActivityResumedListener(this);
123-
}
124-
});
108+
return Tasks.forResult(currentActivity);
125109
}
110+
TaskCompletionSource<Activity> task = new TaskCompletionSource<>();
111+
112+
addOnActivityResumedListener(
113+
new OnActivityResumedListener() {
114+
@Override
115+
public void onResumed(Activity activity) {
116+
task.setResult(activity);
117+
removeOnActivityResumedListener(this);
118+
}
119+
});
126120

127121
return task.getTask();
128122
}
129123
}
130124

131-
void consumeActivityAndCompleteTask(
132-
TaskCompletionSource task, Activity activity, ActivityConsumer consumer) {
133-
try {
134-
consumer.consume(activity);
135-
task.setResult(activity);
136-
} catch (Throwable t) {
137-
task.setException(FirebaseAppDistributionException.wrap(t));
138-
}
139-
}
125+
// /**
126+
// * Get a {@link Task} that will succeed with a result of the app's foregrounded {@link Activity},
127+
// * when one is available.
128+
// *
129+
// * <p>The returned task will never fail. It will instead remain pending indefinitely until some
130+
// * activity comes to the foreground.
131+
// */
132+
// Task<Activity> getForegroundActivity() {
133+
// return getForegroundActivity(activity -> {});
134+
// }
135+
136+
// /**
137+
// * Get a {@link Task} that results from applying a {@link ActivityFunction} applied to the app's
138+
// * foregrounded {@link Activity}, when one is available.
139+
// *
140+
// * <p>The returned task will fail if the {@link ActivityFunction} throws, or the task it returns
141+
// * fails. Otherwise it will never fail, and will wait indefinitely for a foreground activity
142+
// * before applying the function.
143+
// */
144+
// <T> Task<T> applyToForegroundActivityChaining(ActivityFunction<Task<T>> function) {
145+
// synchronized (lock) {
146+
// TaskCompletionSource<T> task = new TaskCompletionSource<>();
147+
// if (currentActivity != null) {
148+
// chainToActivity(task, currentActivity, function);
149+
// } else {
150+
// addOnActivityResumedListener(
151+
// new OnActivityResumedListener() {
152+
// @Override
153+
// public void onResumed(Activity activity) {
154+
// chainToActivity(task, activity, function);
155+
// removeOnActivityResumedListener(this);
156+
// }
157+
// });
158+
// }
159+
//
160+
// return task.getTask();
161+
// }
162+
// }
163+
//
164+
// <T> Task<T> chainToActivity(
165+
// TaskCompletionSource<T> task, Activity activity, ActivityFunction<Task<T>> function) {
166+
// MoreExecutors
167+
// try {
168+
// function.apply(activity)
169+
// .addOnSuccessListener(task::setResult)
170+
// .addOnFailureListener(task::setException)
171+
// .addOnCanceledListener(task::canc)
172+
// continuation.on
173+
// task.setResult(function.apply(activity));
174+
// } catch (Throwable t) {
175+
// task.setException(FirebaseAppDistributionException.wrap(t));
176+
// }
177+
// }
178+
//
179+
// /**
180+
// * Get a {@link Task} that will succeed with a result of applying an {@link ActivityFunction} to
181+
// * the app's foregrounded {@link Activity}, when one is available.
182+
// *
183+
// * <p>The returned task will fail with a {@link FirebaseAppDistributionException} if the {@link
184+
// * ActivityFunction} throws. Otherwise it will never fail, and will wait indefinitely for a
185+
// * foreground activity before applying the function.
186+
// */
187+
// <T> Task<T> applyToForegroundActivity(ActivityFunction<T> function) {
188+
// synchronized (lock) {
189+
// TaskCompletionSource<T> task = new TaskCompletionSource<>();
190+
// if (currentActivity != null) {
191+
// applyToActivityAndCompleteTask(task, currentActivity, function);
192+
// } else {
193+
// addOnActivityResumedListener(
194+
// new OnActivityResumedListener() {
195+
// @Override
196+
// public void onResumed(Activity activity) {
197+
// applyToActivityAndCompleteTask(task, activity, function);
198+
// removeOnActivityResumedListener(this);
199+
// }
200+
// });
201+
// }
202+
//
203+
// return task.getTask();
204+
// }
205+
// }
206+
//
207+
// <T> void applyToActivityAndCompleteTask(
208+
// TaskCompletionSource<T> task, Activity activity, ActivityFunction<T> function) {
209+
// try {
210+
// task.setResult(function.apply(activity));
211+
// } catch (Throwable t) {
212+
// task.setException(FirebaseAppDistributionException.wrap(t));
213+
// }
214+
// }
140215

141216
void addOnActivityCreatedListener(@NonNull OnActivityCreatedListener listener) {
142217
synchronized (lock) {

‎firebase-appdistribution/src/test/java/com/google/firebase/appdistribution/FirebaseAppDistributionLifecycleNotifierTest.java

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020

2121
import android.app.Activity;
2222
import com.google.android.gms.tasks.Task;
23-
import com.google.firebase.appdistribution.FirebaseAppDistributionLifecycleNotifier.ActivityConsumer;
23+
import com.google.firebase.appdistribution.FirebaseAppDistributionLifecycleNotifier.ActivityFunction;
2424
import org.junit.Before;
2525
import org.junit.Test;
2626
import org.junit.runner.RunWith;
@@ -69,7 +69,7 @@ public void getForegroundActivity_withCurrentActivity_succeeds() {
6969
@Test
7070
public void getForegroundActivity_withConsumer_succeedsAndCallsConsumer()
7171
throws FirebaseAppDistributionException {
72-
ActivityConsumer consumer = spy(ActivityConsumer.class);
72+
ActivityFunction consumer = spy(ActivityFunction.class);
7373
Task<Activity> task = lifecycleNotifier.getForegroundActivity(consumer);
7474

7575
// Simulate an activity resuming
@@ -78,7 +78,7 @@ public void getForegroundActivity_withConsumer_succeedsAndCallsConsumer()
7878
assertThat(task.isComplete()).isTrue();
7979
assertThat(task.isSuccessful()).isTrue();
8080
assertThat(task.getResult()).isEqualTo(activity);
81-
verify(consumer).consume(activity);
81+
verify(consumer).apply(activity);
8282
}
8383

8484
@Test
@@ -88,12 +88,12 @@ public void getForegroundActivity_withConsumerAndCurrentActivity_succeedsAndCall
8888
// getForegroundActivity is called
8989
lifecycleNotifier.onActivityResumed(activity);
9090

91-
ActivityConsumer consumer = spy(ActivityConsumer.class);
91+
ActivityFunction consumer = spy(ActivityFunction.class);
9292
Task<Activity> task = lifecycleNotifier.getForegroundActivity(consumer);
9393

9494
assertThat(task.isComplete()).isTrue();
9595
assertThat(task.isSuccessful()).isTrue();
9696
assertThat(task.getResult()).isEqualTo(activity);
97-
verify(consumer).consume(activity);
97+
verify(consumer).apply(activity);
9898
}
9999
}

‎firebase-appdistribution/src/test/java/com/google/firebase/appdistribution/TestUtils.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
import com.google.android.gms.tasks.Task;
2323
import com.google.android.gms.tasks.Tasks;
2424
import com.google.firebase.appdistribution.FirebaseAppDistributionException.Status;
25-
import com.google.firebase.appdistribution.FirebaseAppDistributionLifecycleNotifier.ActivityConsumer;
25+
import com.google.firebase.appdistribution.FirebaseAppDistributionLifecycleNotifier.ActivityFunction;
2626
import java.util.concurrent.ExecutorService;
2727
import java.util.concurrent.TimeUnit;
2828
import org.mockito.stubbing.Answer;
@@ -57,11 +57,11 @@ static void awaitAsyncOperations(ExecutorService executorService) throws Interru
5757

5858
static Answer<Task<Activity>> getForegroundActivityAnswer(Activity activity) {
5959
return invocationOnMock -> {
60-
ActivityConsumer consumer = (ActivityConsumer) invocationOnMock.getArgument(0);
60+
ActivityFunction consumer = (ActivityFunction) invocationOnMock.getArgument(0);
6161
if (consumer == null) {
6262
return Tasks.forException(new IllegalStateException("ActivityConsumer was null"));
6363
}
64-
consumer.consume(activity);
64+
consumer.apply(activity);
6565
return Tasks.forResult(activity);
6666
};
6767
}

0 commit comments

Comments
 (0)