Completely rewrite CredentialsApiHelper.java and hopefully fix memory leak

auth/src/main/java/com/firebase/ui/auth/AuthUI.java

@@ -23,12 +23,15 @@
 import android.support.annotation.Nullable;
 import android.support.annotation.StyleRes;
 import android.support.annotation.VisibleForTesting;
+import android.support.v4.app.FragmentActivity;
 
 import com.facebook.login.LoginManager;
 import com.firebase.ui.auth.ui.FlowParameters;
 import com.firebase.ui.auth.ui.idp.AuthMethodPickerActivity;
+import com.firebase.ui.auth.util.CredentialTaskApi;
 import com.firebase.ui.auth.util.CredentialsApiHelper;
 import com.firebase.ui.auth.util.GoogleApiClientTaskHelper;
+import com.firebase.ui.auth.util.GoogleSignInHelper;
 import com.firebase.ui.auth.util.Preconditions;
 import com.firebase.ui.auth.util.signincontainer.SmartLockBase;
 import com.google.android.gms.auth.api.Auth;
@@ -313,10 +316,12 @@ public static int getDefaultTheme() {
      * Signs the current user out, if one is signed in.
      *
      * @param activity The activity requesting the user be signed out.
-     * @return a task which, upon completion, signals that the user has been signed out
-     * ({@code result.isSuccess()}, or that the sign-out attempt failed unexpectedly
-     * ({@code !result.isSuccess()}).
+     * @return a task which, upon completion, signals that the user has been signed out ({@code
+     * result.isSuccess()}, or that the sign-out attempt failed unexpectedly ({@code
+     * !result.isSuccess()}).
+     * @deprecated use {@link #signOut(FragmentActivity)} instead
      */
+    @Deprecated
     public Task<Void> signOut(@NonNull Activity activity) {
         // Get helper for Google Sign In and Credentials API
         GoogleApiClientTaskHelper taskHelper = GoogleApiClientTaskHelper.getInstance(activity);
@@ -325,7 +330,7 @@ public Task<Void> signOut(@NonNull Activity activity) {
                 .addApi(Auth.GOOGLE_SIGN_IN_API, GoogleSignInOptions.DEFAULT_SIGN_IN);
 
         // Get Credentials Helper
-        CredentialsApiHelper credentialsHelper = CredentialsApiHelper.getInstance(taskHelper);
+        CredentialTaskApi credentialsHelper = CredentialsApiHelper.getInstance(taskHelper);
 
         // Firebase Sign out
         mAuth.signOut();
@@ -359,8 +364,62 @@ public Void then(@NonNull Task<GoogleApiClient> task) throws Exception {
      * silently.
      *
      * @param activity the calling {@link Activity}.
+     * @deprecated use {@link #delete(FragmentActivity)} instead
      */
+    @Deprecated
     public Task<Void> delete(@NonNull Activity activity) {
+        // Initialize SmartLock helper
+        GoogleApiClientTaskHelper gacHelper = GoogleApiClientTaskHelper.getInstance(activity);
+        gacHelper.getBuilder().addApi(Auth.CREDENTIALS_API);
+        CredentialTaskApi credentialHelper = CredentialsApiHelper.getInstance(gacHelper);
+
+        return getDeleteTask(credentialHelper);
+    }
+
+    /**
+     * Signs the current user out, if one is signed in.
+     *
+     * @param activity the activity requesting the user be signed out
+     * @return A task which, upon completion, signals that the user has been signed out ({@link
+     * Task#isSuccessful()}, or that the sign-out attempt failed unexpectedly !{@link
+     * Task#isSuccessful()}).
+     */
+    public Task<Void> signOut(@NonNull FragmentActivity activity) {
+        // Get Credentials Helper
+        GoogleSignInHelper credentialsHelper = GoogleSignInHelper.getInstance(activity);
+
+        // Firebase Sign out
+        mAuth.signOut();
+
+        // Disable credentials auto sign-in
+        Task<Status> disableCredentialsTask = credentialsHelper.disableAutoSignIn();
+
+        // Google sign out
+        Task<Status> signOutTask = credentialsHelper.signOut();
+
+        // Facebook sign out
+        LoginManager.getInstance().logOut();
+
+        // Wait for all tasks to complete
+        return Tasks.whenAll(disableCredentialsTask, signOutTask);
+    }
+
+    /**
+     * Delete the use from FirebaseAuth and delete any associated credentials from the Credentials
+     * API. Returns a {@link Task} that succeeds if the Firebase Auth user deletion succeeds and
+     * fails if the Firebase Auth deletion fails. Credentials deletion failures are handled
+     * silently.
+     *
+     * @param activity the calling {@link Activity}.
+     */
+    public Task<Void> delete(@NonNull FragmentActivity activity) {
+        // Initialize SmartLock helper
+        CredentialTaskApi credentialHelper = GoogleSignInHelper.getInstance(activity);
+
+        return getDeleteTask(credentialHelper);
+    }
+
+    private Task<Void> getDeleteTask(CredentialTaskApi credentialHelper) {
         FirebaseUser firebaseUser = FirebaseAuth.getInstance().getCurrentUser();
         if (firebaseUser == null) {
             // If the current user is null, return a failed task immediately
@@ -370,11 +429,6 @@ public Task<Void> delete(@NonNull Activity activity) {
         // Delete the Firebase user
         Task<Void> deleteUserTask = firebaseUser.delete();
 
-        // Initialize SmartLock helper
-        GoogleApiClientTaskHelper gacHelper = GoogleApiClientTaskHelper.getInstance(activity);
-        gacHelper.getBuilder().addApi(Auth.CREDENTIALS_API);
-        CredentialsApiHelper credentialHelper = CredentialsApiHelper.getInstance(gacHelper);
-
         // Get all SmartLock credentials associated with the user
         List<Credential> credentials = SmartLockBase.credentialsFromFirebaseUser(firebaseUser);
 
@@ -557,8 +611,8 @@ public SignInIntentBuilder setTosUrl(@Nullable String tosUrl) {
          * <p>If no providers are explicitly specified by calling this method, then the email
          * provider is the default supported provider.
          *
-         * @param idpConfigs a list of {@link IdpConfig}s, where each {@link IdpConfig} contains
-         *                   the configuration parameters for the IDP.
+         * @param idpConfigs a list of {@link IdpConfig}s, where each {@link IdpConfig} contains the
+         *                   configuration parameters for the IDP.
          * @see IdpConfig
          */
         public SignInIntentBuilder setProviders(@NonNull List<IdpConfig> idpConfigs) {

auth/src/main/java/com/firebase/ui/auth/provider/GoogleProvider.java

@@ -29,7 +29,7 @@
 import com.firebase.ui.auth.AuthUI.IdpConfig;
 import com.firebase.ui.auth.IdpResponse;
 import com.firebase.ui.auth.R;
-import com.firebase.ui.auth.util.GoogleApiConstants;
+import com.firebase.ui.auth.util.GoogleApiHelper;
 import com.google.android.gms.auth.api.Auth;
 import com.google.android.gms.auth.api.signin.GoogleSignInAccount;
 import com.google.android.gms.auth.api.signin.GoogleSignInOptions;
@@ -80,7 +80,7 @@ public GoogleProvider(FragmentActivity activity, IdpConfig idpConfig, @Nullable
         }
 
         mGoogleApiClient = new GoogleApiClient.Builder(activity)
-                .enableAutoManage(activity, GoogleApiConstants.AUTO_MANAGE_ID0, this)
+                .enableAutoManage(activity, GoogleApiHelper.getSafeAutoManageId(), this)
                 .addApi(Auth.GOOGLE_SIGN_IN_API, builder.build())
                 .build();
     }

auth/src/main/java/com/firebase/ui/auth/ui/email/CheckEmailFragment.java

@@ -23,7 +23,7 @@
 import com.firebase.ui.auth.ui.TaskFailureLogger;
 import com.firebase.ui.auth.ui.User;
 import com.firebase.ui.auth.ui.email.fieldvalidators.EmailFieldValidator;
-import com.firebase.ui.auth.util.GoogleApiConstants;
+import com.firebase.ui.auth.util.GoogleApiHelper;
 import com.google.android.gms.auth.api.Auth;
 import com.google.android.gms.auth.api.credentials.Credential;
 import com.google.android.gms.auth.api.credentials.CredentialPickerConfig;
@@ -234,7 +234,7 @@ private void showEmailAutoCompleteHint() {
     private PendingIntent getEmailHintIntent() {
         GoogleApiClient client = new GoogleApiClient.Builder(getContext())
                 .addApi(Auth.CREDENTIALS_API)
-                .enableAutoManage(getActivity(), GoogleApiConstants.AUTO_MANAGE_ID3,
+                .enableAutoManage(getActivity(), GoogleApiHelper.getSafeAutoManageId(),
                                   new GoogleApiClient.OnConnectionFailedListener() {
                                       @Override
                                       public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {

auth/src/main/java/com/firebase/ui/auth/util/CredentialTaskApi.java

@@ -0,0 +1,11 @@
+package com.firebase.ui.auth.util;
+
+import com.google.android.gms.auth.api.credentials.Credential;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.Task;
+
+public interface CredentialTaskApi {
+    Task<Status> disableAutoSignIn();
+
+    Task<Status> delete(Credential credential);
+}

auth/src/main/java/com/firebase/ui/auth/util/CredentialsApiHelper.java

@@ -31,7 +31,8 @@
  * A {@link com.google.android.gms.tasks.Task Task} based wrapper for the Smart Lock for Passwords
  * API.
  */
-public class CredentialsApiHelper {
+@Deprecated
+public class CredentialsApiHelper implements CredentialTaskApi {
     @NonNull
     private final GoogleApiClientTaskHelper mClientHelper;
 
@@ -51,6 +52,7 @@ public static CredentialsApiHelper getInstance(GoogleApiClientTaskHelper taskHel
         return new CredentialsApiHelper(taskHelper);
     }
 
+    @Override
     public Task<Status> delete(final Credential credential) {
         return mClientHelper.getConnectedGoogleApiClient().continueWithTask(
                 new ExceptionForwardingContinuation<GoogleApiClient, Status>() {
@@ -64,6 +66,7 @@ protected void process(
                 });
     }
 
+    @Override
     public Task<Status> disableAutoSignIn() {
         return mClientHelper.getConnectedGoogleApiClient().continueWithTask(
                 new ExceptionForwardingContinuation<GoogleApiClient, Status>() {
@@ -82,20 +85,20 @@ public void onResult(@NonNull Status status) {
                 });
     }
 
-    private abstract static class ExceptionForwardingContinuation<InT, OutT>
-            implements Continuation<InT, Task<OutT>> {
+    private abstract static class ExceptionForwardingContinuation<TIn, TOut>
+            implements Continuation<TIn, Task<TOut>> {
 
         @Override
-        public final Task<OutT> then(@NonNull Task<InT> task) throws Exception {
-            TaskCompletionSource<OutT> source = new TaskCompletionSource<>();
+        public final Task<TOut> then(@NonNull Task<TIn> task) throws Exception {
+            TaskCompletionSource<TOut> source = new TaskCompletionSource<>();
             // calling task.getResult() will implicitly re-throw the exception of the original
             // task, which will be returned as the result for the output task. Similarly,
             // if process() throws an exception, this will be turned into the task result.
             process(task.getResult(), source);
             return source.getTask();
         }
 
-        protected abstract void process(InT in, TaskCompletionSource<OutT> result);
+        protected abstract void process(TIn in, TaskCompletionSource<TOut> result);
     }
 
     private static final class TaskResultCaptor<R extends Result> implements ResultCallback<R> {

auth/src/main/java/com/firebase/ui/auth/util/GoogleApiClientTaskHelper.java

@@ -33,6 +33,7 @@
  * {@link com.google.android.gms.common.api.GoogleApiClient} instance, which manages a single
  * instance per activity.
  */
+@Deprecated
 public class GoogleApiClientTaskHelper {
 
     private static final IdentityHashMap<Activity, GoogleApiClientTaskHelper> INSTANCES

auth/src/main/java/com/firebase/ui/auth/util/GoogleApiHelper.java

@@ -0,0 +1,90 @@
+package com.firebase.ui.auth.util;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.FragmentActivity;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+import java.net.ConnectException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A {@link Task} based wrapper to get a connect {@link GoogleApiClient}.
+ */
+public abstract class GoogleApiHelper implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
+    private static final AtomicInteger SAFE_ID = new AtomicInteger(0);
+
+    protected GoogleApiClient mClient;
+    private TaskCompletionSource<Bundle> mGoogleApiConnectionTask = new TaskCompletionSource<>();
+
+    protected GoogleApiHelper(FragmentActivity activity, GoogleApiClient.Builder builder) {
+        builder.enableAutoManage(activity, getSafeAutoManageId(), this);
+        builder.addConnectionCallbacks(this);
+        mClient = builder.build();
+    }
+
+    public static int getSafeAutoManageId() {
+        return SAFE_ID.getAndIncrement();
+    }
+
+    public Task<Bundle> getConnectedApiTask() {
+        return mGoogleApiConnectionTask.getTask();
+    }
+
+    @Override
+    public void onConnected(@Nullable Bundle bundle) {
+        mGoogleApiConnectionTask.setResult(bundle);
+    }
+
+    @Override
+    public void onConnectionSuspended(int i) {
+        // Just wait
+    }
+
+    @Override
+    public void onConnectionFailed(@NonNull ConnectionResult result) {
+        mGoogleApiConnectionTask.setException(new ConnectException(result.toString()));
+    }
+
+    protected static final class TaskResultCaptor<R extends Result> implements ResultCallback<R> {
+        private TaskCompletionSource<R> mSource;
+
+        public TaskResultCaptor(TaskCompletionSource<R> source) {
+            mSource = source;
+        }
+
+        @Override
+        public void onResult(@NonNull R result) {
+            mSource.setResult(result);
+        }
+    }
+
+    protected static class ExceptionForwarder<TResult> implements OnCompleteListener<TResult> {
+        private TaskCompletionSource mSource;
+        private OnSuccessListener<TResult> mListener;
+
+        public ExceptionForwarder(TaskCompletionSource source,
+                                  OnSuccessListener<TResult> listener) {
+            mSource = source;
+            mListener = listener;
+        }
+
+        @Override
+        public void onComplete(@NonNull Task<TResult> task) {
+            if (task.isSuccessful()) {
+                mListener.onSuccess(task.getResult());
+            } else {
+                mSource.setException(task.getException());
+            }
+        }
+    }
+}