Kill SignInDelegate ☠️

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

@@ -1,91 +1,113 @@
 package com.firebase.ui.auth;
 
+import android.arch.lifecycle.Observer;
+import android.arch.lifecycle.ViewModelProviders;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.net.ConnectivityManager;
 import android.os.Bundle;
 import android.support.annotation.RestrictTo;
-import android.util.Log;
 
 import com.firebase.ui.auth.data.model.FlowParameters;
+import com.firebase.ui.auth.data.model.Resource;
+import com.firebase.ui.auth.data.model.State;
+import com.firebase.ui.auth.data.model.UserCancellationException;
+import com.firebase.ui.auth.data.remote.SignInKickstarter;
 import com.firebase.ui.auth.ui.HelperActivityBase;
-import com.firebase.ui.auth.util.ExtraConstants;
 import com.firebase.ui.auth.util.PlayServicesHelper;
-import com.firebase.ui.auth.util.signincontainer.SignInDelegate;
+import com.firebase.ui.auth.util.ui.FlowUtils;
 import com.firebase.ui.auth.viewmodel.RequestCodes;
 
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
 public class KickoffActivity extends HelperActivityBase {
-    private static final String TAG = "KickoffActivity";
     private static final String IS_WAITING_FOR_PLAY_SERVICES = "is_waiting_for_play_services";
 
+    private SignInKickstarter mKickstarter;
     private boolean mIsWaitingForPlayServices = false;
 
     public static Intent createIntent(Context context, FlowParameters flowParams) {
         return HelperActivityBase.createBaseIntent(context, KickoffActivity.class, flowParams);
     }
 
     @Override
-    protected void onCreate(Bundle savedInstance) {
-        super.onCreate(savedInstance);
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mKickstarter = ViewModelProviders.of(this).get(SignInKickstarter.class);
+        mKickstarter.init(getFlowParams());
+        mKickstarter.getOperation().observe(this, new Observer<Resource<IdpResponse>>() {
+            @Override
+            public void onChanged(Resource<IdpResponse> resource) {
+                if (resource.getState() == State.LOADING) {
+                    getDialogHolder().showLoadingDialog(R.string.fui_progress_dialog_loading);
+                    return;
+                }
+                getDialogHolder().dismissDialog();
 
-        if (savedInstance == null || savedInstance.getBoolean(IS_WAITING_FOR_PLAY_SERVICES)) {
-            if (isOffline()) {
-                Log.d(TAG, "No network connection");
-                finish(RESULT_CANCELED, IdpResponse.getErrorIntent(
-                        new FirebaseUiException(ErrorCodes.NO_NETWORK)));
-                return;
+                if (resource.getState() == State.SUCCESS) {
+                    finish(RESULT_OK, resource.getValue().toIntent());
+                } else if (resource.getState() == State.FAILURE) {
+                    Exception e = resource.getException();
+                    if (!FlowUtils.handleError(KickoffActivity.this, e)) {
+                        finish(RESULT_CANCELED, IdpResponse.getErrorIntent(e));
+                    } else if (e instanceof UserCancellationException) {
+                        finish(RESULT_CANCELED, null);
+                    }
+                }
             }
+        });
 
-            boolean isPlayServicesAvailable = PlayServicesHelper.makePlayServicesAvailable(
-                    this,
-                    RequestCodes.PLAY_SERVICES_CHECK,
-                    new DialogInterface.OnCancelListener() {
-                        @Override
-                        public void onCancel(DialogInterface dialog) {
-                            finish(RESULT_CANCELED, IdpResponse.getErrorIntent(
-                                    new FirebaseUiException(ErrorCodes.PLAY_SERVICES_UPDATE_CANCELLED)));
-                        }
-                    });
+        if (savedInstanceState == null || savedInstanceState.getBoolean(IS_WAITING_FOR_PLAY_SERVICES)) {
+            init();
+        }
+    }
 
-            if (isPlayServicesAvailable) {
-                start();
-            } else {
-                mIsWaitingForPlayServices = true;
-            }
+    private void init() {
+        if (isOffline()) {
+            finish(RESULT_CANCELED, IdpResponse.getErrorIntent(
+                    new FirebaseUiException(ErrorCodes.NO_NETWORK)));
+            return;
+        }
+
+        boolean isPlayServicesAvailable = PlayServicesHelper.makePlayServicesAvailable(
+                this,
+                RequestCodes.PLAY_SERVICES_CHECK,
+                new DialogInterface.OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialog) {
+                        finish(RESULT_CANCELED, IdpResponse.getErrorIntent(
+                                new FirebaseUiException(ErrorCodes.PLAY_SERVICES_UPDATE_CANCELLED)));
+                    }
+                });
+
+        if (isPlayServicesAvailable) {
+            mKickstarter.start();
+        } else {
+            mIsWaitingForPlayServices = true;
         }
     }
 
     @Override
     public void onSaveInstanceState(Bundle outState) {
-        // It doesn't matter what we put here, we just don't want outState to be empty
-        outState.putBoolean(ExtraConstants.HAS_EXISTING_INSTANCE, true);
-        outState.putBoolean(IS_WAITING_FOR_PLAY_SERVICES, mIsWaitingForPlayServices);
         super.onSaveInstanceState(outState);
+        outState.putBoolean(IS_WAITING_FOR_PLAY_SERVICES, mIsWaitingForPlayServices);
     }
 
     @Override
     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
         super.onActivityResult(requestCode, resultCode, data);
         if (requestCode == RequestCodes.PLAY_SERVICES_CHECK) {
             if (resultCode == RESULT_OK) {
-                start();
+                mKickstarter.start();
             } else {
                 finish(RESULT_CANCELED, IdpResponse.getErrorIntent(
                         new FirebaseUiException(ErrorCodes.PLAY_SERVICES_UPDATE_CANCELLED)));
             }
         } else {
-            SignInDelegate delegate = SignInDelegate.getInstance(this);
-            if (delegate != null) delegate.onActivityResult(requestCode, resultCode, data);
+            mKickstarter.onActivityResult(requestCode, resultCode, data);
         }
     }
 
-    private void start() {
-        FlowParameters flowParams = getFlowParams();
-        SignInDelegate.delegate(this, flowParams);
-    }
-
     /**
      * Check if there is an active or soon-to-be-active network connection.
      *

auth/src/main/java/com/firebase/ui/auth/data/model/FlowParameters.java

@@ -91,16 +91,6 @@ public static FlowParameters fromBundle(Bundle bundle) {
         return bundle.getParcelable(ExtraConstants.EXTRA_FLOW_PARAMS);
     }
 
-    /**
-     * Create a bundle containing this FlowParameters object as {@link
-     * ExtraConstants#EXTRA_FLOW_PARAMS}.
-     */
-    public Bundle toBundle() {
-        Bundle bundle = new Bundle();
-        bundle.putParcelable(ExtraConstants.EXTRA_FLOW_PARAMS, this);
-        return bundle;
-    }
-
     @Override
     public void writeToParcel(Parcel dest, int flags) {
         dest.writeString(appName);

auth/src/main/java/com/firebase/ui/auth/data/remote/SignInKickstarter.java

@@ -0,0 +1,218 @@
+package com.firebase.ui.auth.data.remote;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+
+import com.firebase.ui.auth.AuthUI;
+import com.firebase.ui.auth.IdpResponse;
+import com.firebase.ui.auth.data.model.IntentRequiredException;
+import com.firebase.ui.auth.data.model.PendingIntentRequiredException;
+import com.firebase.ui.auth.data.model.Resource;
+import com.firebase.ui.auth.data.model.User;
+import com.firebase.ui.auth.data.model.UserCancellationException;
+import com.firebase.ui.auth.ui.email.EmailActivity;
+import com.firebase.ui.auth.ui.idp.AuthMethodPickerActivity;
+import com.firebase.ui.auth.ui.idp.SingleSignInActivity;
+import com.firebase.ui.auth.ui.phone.PhoneActivity;
+import com.firebase.ui.auth.util.GoogleApiUtils;
+import com.firebase.ui.auth.util.data.ProviderUtils;
+import com.firebase.ui.auth.viewmodel.AuthViewModelBase;
+import com.firebase.ui.auth.viewmodel.RequestCodes;
+import com.google.android.gms.auth.api.credentials.Credential;
+import com.google.android.gms.auth.api.credentials.CredentialRequest;
+import com.google.android.gms.auth.api.credentials.CredentialRequestResponse;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.common.api.CommonStatusCodes;
+import com.google.android.gms.common.api.ResolvableApiException;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.auth.AuthResult;
+import com.google.firebase.auth.EmailAuthProvider;
+import com.google.firebase.auth.FacebookAuthProvider;
+import com.google.firebase.auth.FirebaseAuthInvalidCredentialsException;
+import com.google.firebase.auth.FirebaseAuthInvalidUserException;
+import com.google.firebase.auth.GoogleAuthProvider;
+import com.google.firebase.auth.PhoneAuthProvider;
+import com.google.firebase.auth.TwitterAuthProvider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SignInKickstarter extends AuthViewModelBase<IdpResponse> {
+    public SignInKickstarter(Application application) {
+        super(application);
+    }
+
+    public void start() {
+        // Only support password credentials if email auth is enabled
+        boolean supportPasswords = ProviderUtils.getConfigFromIdps(
+                getArguments().providerInfo, EmailAuthProvider.PROVIDER_ID) != null;
+        List<String> accountTypes = getCredentialAccountTypes();
+
+        // If the request will be empty, avoid the step entirely
+        boolean willRequestCredentials = supportPasswords || accountTypes.size() > 0;
+
+        if (getArguments().enableCredentials && willRequestCredentials) {
+            setResult(Resource.<IdpResponse>forLoading());
+
+            GoogleApiUtils.getCredentialsClient(getApplication())
+                    .request(new CredentialRequest.Builder()
+                            .setPasswordLoginSupported(supportPasswords)
+                            .setAccountTypes(accountTypes.toArray(new String[accountTypes.size()]))
+                            .build())
+                    .addOnCompleteListener(new OnCompleteListener<CredentialRequestResponse>() {
+                        @Override
+                        public void onComplete(@NonNull Task<CredentialRequestResponse> task) {
+                            try {
+                                handleCredential(
+                                        task.getResult(ApiException.class).getCredential());
+                            } catch (ResolvableApiException e) {
+                                if (e.getStatusCode() == CommonStatusCodes.RESOLUTION_REQUIRED) {
+                                    setResult(Resource.<IdpResponse>forUsableFailure(
+                                            new PendingIntentRequiredException(
+                                                    e.getResolution(), RequestCodes.CRED_HINT)));
+                                } else {
+                                    startAuthMethodChoice();
+                                }
+                            } catch (ApiException e) {
+                                startAuthMethodChoice();
+                            }
+                        }
+                    });
+        } else {
+            startAuthMethodChoice();
+        }
+    }
+
+    private void startAuthMethodChoice() {
+        List<AuthUI.IdpConfig> idpConfigs = getArguments().providerInfo;
+
+        // If there is only one provider selected, launch the flow directly
+        if (idpConfigs.size() == 1) {
+            AuthUI.IdpConfig firstIdpConfig = idpConfigs.get(0);
+            String firstProvider = firstIdpConfig.getProviderId();
+            switch (firstProvider) {
+                case EmailAuthProvider.PROVIDER_ID:
+                    setResult(Resource.<IdpResponse>forUsableFailure(new IntentRequiredException(
+                            EmailActivity.createIntent(getApplication(), getArguments()),
+                            RequestCodes.EMAIL_FLOW)));
+                    break;
+                case PhoneAuthProvider.PROVIDER_ID:
+                    setResult(Resource.<IdpResponse>forUsableFailure(new IntentRequiredException(
+                            PhoneActivity.createIntent(
+                                    getApplication(), getArguments(), firstIdpConfig.getParams()),
+                            RequestCodes.PHONE_FLOW)));
+                    break;
+                default:
+                    redirectSignIn(firstProvider, null);
+                    break;
+            }
+        } else {
+            setResult(Resource.<IdpResponse>forUsableFailure(new IntentRequiredException(
+                    AuthMethodPickerActivity.createIntent(getApplication(), getArguments()),
+                    RequestCodes.AUTH_PICKER_FLOW)));
+        }
+    }
+
+    private void redirectSignIn(String provider, String email) {
+        switch (provider) {
+            case EmailAuthProvider.PROVIDER_ID:
+                setResult(Resource.<IdpResponse>forUsableFailure(new IntentRequiredException(
+                        EmailActivity.createIntent(getApplication(), getArguments(), email),
+                        RequestCodes.EMAIL_FLOW)));
+                break;
+            case GoogleAuthProvider.PROVIDER_ID:
+            case FacebookAuthProvider.PROVIDER_ID:
+            case TwitterAuthProvider.PROVIDER_ID:
+                setResult(Resource.<IdpResponse>forUsableFailure(new IntentRequiredException(
+                        SingleSignInActivity.createIntent(
+                                getApplication(),
+                                getArguments(),
+                                new User.Builder(provider, email).build()),
+                        RequestCodes.PROVIDER_FLOW)));
+                break;
+            default:
+                startAuthMethodChoice();
+        }
+    }
+
+    private List<String> getCredentialAccountTypes() {
+        List<String> accounts = new ArrayList<>();
+        for (AuthUI.IdpConfig idpConfig : getArguments().providerInfo) {
+            @AuthUI.SupportedProvider String providerId = idpConfig.getProviderId();
+            if (providerId.equals(GoogleAuthProvider.PROVIDER_ID)) {
+                accounts.add(ProviderUtils.providerIdToAccountType(providerId));
+            }
+        }
+        return accounts;
+    }
+
+    public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
+        switch (requestCode) {
+            case RequestCodes.CRED_HINT:
+                if (resultCode == Activity.RESULT_OK) {
+                    handleCredential((Credential) data.getParcelableExtra(Credential.EXTRA_KEY));
+                } else {
+                    startAuthMethodChoice();
+                }
+                break;
+            case RequestCodes.AUTH_PICKER_FLOW:
+            case RequestCodes.EMAIL_FLOW:
+            case RequestCodes.PHONE_FLOW:
+            case RequestCodes.PROVIDER_FLOW:
+                IdpResponse response = IdpResponse.fromResultIntent(data);
+                if (response == null) {
+                    setResult(Resource.<IdpResponse>forFailure(new UserCancellationException()));
+                } else if (response.isSuccessful()) {
+                    setResult(Resource.forSuccess(response));
+                } else {
+                    setResult(Resource.<IdpResponse>forFailure(response.getError()));
+                }
+        }
+    }
+
+    private void handleCredential(final Credential credential) {
+        String id = credential.getId();
+        String password = credential.getPassword();
+        if (TextUtils.isEmpty(password)) {
+            String identity = credential.getAccountType();
+            if (identity == null) {
+                startAuthMethodChoice();
+            } else {
+                redirectSignIn(
+                        ProviderUtils.accountTypeToProviderId(credential.getAccountType()), id);
+            }
+        } else {
+            final IdpResponse response = new IdpResponse.Builder(
+                    new User.Builder(EmailAuthProvider.PROVIDER_ID, id).build()).build();
+
+            getAuth().signInWithEmailAndPassword(id, password)
+                    .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
+                        @Override
+                        public void onSuccess(AuthResult result) {
+                            setResult(Resource.forSuccess(response));
+                        }
+                    })
+                    .addOnFailureListener(new OnFailureListener() {
+                        @Override
+                        public void onFailure(@NonNull Exception e) {
+                            if (e instanceof FirebaseAuthInvalidUserException
+                                    || e instanceof FirebaseAuthInvalidCredentialsException) {
+                                // In this case the credential saved in SmartLock was not
+                                // a valid credential, we should delete it from SmartLock
+                                // before continuing.
+                                GoogleApiUtils.getCredentialsClient(getApplication())
+                                        .delete(credential);
+                            }
+                            startAuthMethodChoice();
+                        }
+                    });
+        }
+    }
+}