Don't kick off second task until first is finished

Author: lfkellogg

firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/FirebaseAppDistributionException.java

@@ -17,6 +17,7 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.google.firebase.FirebaseException;
+import com.google.firebase.appdistribution.Constants.ErrorMessages;
 
 /** Possible exceptions thrown in FirebaseAppDistribution */
 public class FirebaseAppDistributionException extends FirebaseException {
@@ -98,4 +99,13 @@ public AppDistributionRelease getRelease() {
   public Status getErrorCode() {
     return status;
   }
+
+  static FirebaseAppDistributionException wrap(Throwable t) {
+    // We never want to wrap a FirebaseAppDistributionException
+    if (t instanceof FirebaseAppDistributionException) {
+      return (FirebaseAppDistributionException) t;
+    }
+    return new FirebaseAppDistributionException(
+        String.format("%s: %s", ErrorMessages.UNKNOWN_ERROR, t.getMessage()), Status.UNKNOWN, t);
+  }
 }

firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/TaskUtils.java

@@ -19,18 +19,26 @@
 import com.google.android.gms.tasks.TaskCompletionSource;
 import com.google.android.gms.tasks.Tasks;
 import com.google.auto.value.AutoValue;
-import com.google.firebase.appdistribution.Constants.ErrorMessages;
 import com.google.firebase.appdistribution.FirebaseAppDistributionException.Status;
 import com.google.firebase.appdistribution.internal.LogWrapper;
 import java.util.concurrent.Executor;
 
 class TaskUtils {
   private static final String TAG = "TaskUtils:";
 
+  /**
+   * A functional interface to wrap a function that returns some result of a possibly long-running
+   * operation, and could potentially throw a {@link FirebaseAppDistributionException}.
+   */
   interface Operation<TResult> {
     TResult run() throws FirebaseAppDistributionException;
   }
 
+  /** A functional interface to wrap a function that produces a {@link Task}. */
+  interface TaskSource<TResult> {
+    Task<TResult> get();
+  }
+
   /**
    * Runs a long running operation inside a {@link Task}, wrapping any errors in {@link
    * FirebaseAppDistributionException}.
@@ -53,10 +61,8 @@ static <TResult> Task<TResult> runAsyncInTask(Executor executor, Operation<TResu
         () -> {
           try {
             taskCompletionSource.setResult(operation.run());
-          } catch (FirebaseAppDistributionException e) {
-            taskCompletionSource.setException(e);
           } catch (Throwable t) {
-            taskCompletionSource.setException(wrapException(t));
+            taskCompletionSource.setException(FirebaseAppDistributionException.wrap(t));
           }
         });
     return taskCompletionSource.getTask();
@@ -81,7 +87,7 @@ static <TResult> Task<TResult> handleTaskFailure(Task<TResult> task) {
       LogWrapper.getInstance().e(TAG + "Task failed to complete due to " + e.getMessage(), e);
       return e instanceof FirebaseAppDistributionException
           ? task
-          : Tasks.forException(wrapException(e));
+          : Tasks.forException(FirebaseAppDistributionException.wrap(e));
     }
     return task;
   }
@@ -116,28 +122,26 @@ static <T1, T2> CombinedTaskResults<T1, T2> create(T1 first, T2 second) {
    *
    * <pre>{@code
    * runFirstAsyncTask()
-   *   .onSuccessTask(combineWithResultOf(runSecondAsyncTask())
+   *   .onSuccessTask(combineWithResultOf(() -> startSecondAsyncTask())
    *   .addOnSuccessListener(
    *       results ->
    *           doSomethingWithBothResults(results.result1(), results.result2()));
    * }</pre>
    *
-   * @param secondTask The next task to run
+   * @param secondTaskSource A {@link TaskSource} providing the next task to run
    * @param <T1> The result type of the first task
    * @param <T2> The result type of the second task
    * @return A {@link SuccessContinuation} that will return a new task with result type {@link
    *     CombinedTaskResults}, combining the results of both tasks
    */
   static <T1, T2> SuccessContinuation<T1, CombinedTaskResults<T1, T2>> combineWithResultOf(
-      Task<T2> secondTask) {
+      TaskSource<T2> secondTaskSource) {
     return firstResult ->
-        secondTask.onSuccessTask(
-            secondResult -> Tasks.forResult(CombinedTaskResults.create(firstResult, secondResult)));
-  }
-
-  private static FirebaseAppDistributionException wrapException(Throwable t) {
-    return new FirebaseAppDistributionException(
-        String.format("%s: %s", ErrorMessages.UNKNOWN_ERROR, t.getMessage()), Status.UNKNOWN, t);
+        secondTaskSource
+            .get()
+            .onSuccessTask(
+                secondResult ->
+                    Tasks.forResult(CombinedTaskResults.create(firstResult, secondResult)));
   }
 
   static void safeSetTaskException(TaskCompletionSource taskCompletionSource, Exception e) {

firebase-appdistribution/src/main/java/com/google/firebase/appdistribution/TesterSignInManager.java

@@ -107,11 +107,13 @@ void onActivityStarted(Activity activity) {
       return;
     } else {
       // Throw error if app reentered during sign in
-      if (awaitingResultFromBrowser()) {
-        LogWrapper.getInstance().e("App Resumed without sign in flow completing.");
-        setSignInTaskCompletionError(
-            new FirebaseAppDistributionException(
-                Constants.ErrorMessages.AUTHENTICATION_CANCELED, AUTHENTICATION_CANCELED));
+      synchronized (signInTaskLock) {
+        if (awaitingResultFromBrowser()) {
+          LogWrapper.getInstance().e("App Resumed without sign in flow completing.");
+          setSignInTaskCompletionError(
+              new FirebaseAppDistributionException(
+                  Constants.ErrorMessages.AUTHENTICATION_CANCELED, AUTHENTICATION_CANCELED));
+        }
       }
     }
   }
@@ -139,7 +141,7 @@ public Task<Void> signInTester() {
           .getId()
           .addOnFailureListener(
               handleTaskFailure(ErrorMessages.AUTHENTICATION_ERROR, Status.AUTHENTICATION_FAILURE))
-          .onSuccessTask(combineWithResultOf(lifecycleNotifier.getForegroundActivity()))
+          .onSuccessTask(combineWithResultOf(() -> lifecycleNotifier.getForegroundActivity()))
           .addOnSuccessListener(
               fidAndActivity -> {
                 synchronized (signInTaskLock) {