Refactor welcome-back password flow, add ViewModel tests (#1096)

Author: samtstern

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

@@ -15,7 +15,7 @@
 import com.firebase.ui.auth.util.AuthHelper;
 import com.firebase.ui.auth.util.ExtraConstants;
 import com.firebase.ui.auth.util.signincontainer.SaveSmartLock;
-import com.firebase.ui.auth.util.ui.FlowHolder;
+import com.firebase.ui.auth.viewmodel.FlowHolder;
 import com.google.firebase.auth.FirebaseUser;
 
 import static com.firebase.ui.auth.util.Preconditions.checkNotNull;

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

@@ -36,6 +36,7 @@
 import com.firebase.ui.auth.util.ExtraConstants;
 import com.firebase.ui.auth.util.ui.ImeHelper;
 import com.firebase.ui.auth.util.ui.fieldvalidators.EmailFieldValidator;
+import com.firebase.ui.auth.viewmodel.email.RecoverPasswordHandler;
 import com.google.firebase.auth.FirebaseAuthInvalidCredentialsException;
 import com.google.firebase.auth.FirebaseAuthInvalidUserException;
 

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

@@ -14,40 +14,41 @@
 
 package com.firebase.ui.auth.ui.email;
 
+import android.arch.lifecycle.Observer;
+import android.arch.lifecycle.ViewModelProviders;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentSender;
 import android.graphics.Typeface;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.annotation.RestrictTo;
 import android.support.design.widget.TextInputLayout;
 import android.text.Spannable;
 import android.text.SpannableStringBuilder;
 import android.text.TextUtils;
 import android.text.style.StyleSpan;
+import android.util.Log;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.EditText;
 import android.widget.TextView;
 
+import com.firebase.ui.auth.ErrorCodes;
 import com.firebase.ui.auth.IdpResponse;
 import com.firebase.ui.auth.R;
+import com.firebase.ui.auth.data.model.FirebaseUiException;
 import com.firebase.ui.auth.data.model.FlowParameters;
-import com.firebase.ui.auth.data.model.User;
-import com.firebase.ui.auth.data.remote.ProfileMerger;
+import com.firebase.ui.auth.data.model.Resource;
+import com.firebase.ui.auth.data.model.State;
 import com.firebase.ui.auth.ui.AppCompatBase;
 import com.firebase.ui.auth.ui.HelperActivityBase;
-import com.firebase.ui.auth.ui.TaskFailureLogger;
 import com.firebase.ui.auth.util.ExtraConstants;
 import com.firebase.ui.auth.util.data.ProviderUtils;
-import com.firebase.ui.auth.util.signincontainer.SaveSmartLock;
 import com.firebase.ui.auth.util.ui.ImeHelper;
-import com.google.android.gms.tasks.OnFailureListener;
-import com.google.android.gms.tasks.OnSuccessListener;
+import com.firebase.ui.auth.viewmodel.PendingResolution;
+import com.firebase.ui.auth.viewmodel.email.WelcomeBackPasswordHandler;
 import com.google.firebase.auth.AuthCredential;
-import com.google.firebase.auth.AuthResult;
-import com.google.firebase.auth.EmailAuthProvider;
 
 /**
  * Activity to link a pre-existing email/password account to a new IDP sign-in by confirming the
@@ -62,8 +63,8 @@ public class WelcomeBackPasswordPrompt extends AppCompatBase
     private TextInputLayout mPasswordLayout;
     private EditText mPasswordField;
     private IdpResponse mIdpResponse;
-    @Nullable
-    private SaveSmartLock mSaveSmartLock;
+
+    private WelcomeBackPasswordHandler mHandler;
 
     public static Intent createIntent(
             Context context,
@@ -81,7 +82,6 @@ protected void onCreate(Bundle savedInstanceState) {
         // Show keyboard
         getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
 
-        mSaveSmartLock = getAuthHelper().getSaveSmartLockInstance(this);
         mIdpResponse = IdpResponse.fromResultIntent(getIntent());
         mEmail = mIdpResponse.getEmail();
 
@@ -106,21 +106,88 @@ protected void onCreate(Bundle savedInstanceState) {
         // Click listeners
         findViewById(R.id.button_done).setOnClickListener(this);
         findViewById(R.id.trouble_signing_in).setOnClickListener(this);
+
+        // Initialize ViewModel with arguments
+        mHandler = ViewModelProviders.of(this).get(WelcomeBackPasswordHandler.class);
+        mHandler.init(getFlowHolder().getArguments());
+
+        // Fire resolutions when asked
+        mHandler.getPendingResolution().observe(this,
+                new Observer<PendingResolution>() {
+                    @Override
+                    public void onChanged(@Nullable PendingResolution resolution) {
+                        onPendingResolution(resolution);
+                    }
+                });
+
+        // Observe the state of the main auth operation
+        mHandler.getSignInResult().observe(this, new Observer<Resource<IdpResponse>>() {
+            @Override
+            public void onChanged(@Nullable Resource<IdpResponse> resource) {
+                onAuthResult(resource);
+            }
+        });
     }
 
     @Override
-    public void onClick(View view) {
-        final int id = view.getId();
-        if (id == R.id.button_done) {
-            validateAndSignIn();
-        } else if (id == R.id.trouble_signing_in) {
-            startActivity(RecoverPasswordActivity.createIntent(
-                    this,
-                    getFlowParams(),
-                    mEmail));
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        // Forward activity results to the ViewModel
+        if (!mHandler.onActivityResult(requestCode, resultCode, data)) {
+            super.onActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    private void onAuthResult(@Nullable Resource<IdpResponse> resource) {
+        if (resource == null) {
+            Log.w(TAG, "Got null resource, ignoring.");
+            return;
+        }
+
+        if (resource.getState() == State.LOADING) {
+            getDialogHolder().showLoadingDialog(R.string.fui_progress_dialog_signing_in);
+        }
+
+        if (resource.getState() == State.SUCCESS) {
+            getDialogHolder().dismissDialog();
+            Log.d(TAG, "onAuthResult:SUCCESS:" + resource.getValue());
+
+            finish(RESULT_OK, resource.getValue().toIntent());
+        }
+
+        if (resource.getState() == State.FAILURE) {
+            getDialogHolder().dismissDialog();
+
+            // TODO: Is this message what we want?
+            String message = resource.getException().getLocalizedMessage();
+            mPasswordLayout.setError(message);
         }
     }
 
+    private void onPendingResolution(@Nullable PendingResolution resolution) {
+        if (resolution == null) {
+            Log.e(TAG, "Got null resolution, can't do anything");
+            return;
+        }
+
+        try {
+            startIntentSenderForResult(resolution.getPendingIntent().getIntentSender(),
+                    resolution.getRequestCode(), null, 0, 0, 0);
+        } catch (IntentSender.SendIntentException e) {
+            Log.e(TAG, "Failed to send resolution.", e);
+
+            IdpResponse errorResponse = IdpResponse.fromError(
+                    new FirebaseUiException(ErrorCodes.UNKNOWN_ERROR, getString(R.string.fui_general_error), e));
+            finish(RESULT_OK, errorResponse.toIntent());
+        }
+    }
+
+    private void onForgotPasswordClicked() {
+        startActivity(RecoverPasswordActivity.createIntent(
+                this,
+                getFlowParams(),
+                mEmail));
+    }
+
     @Override
     public void onDonePressed() {
         validateAndSignIn();
@@ -138,64 +205,18 @@ private void validateAndSignIn(final String email, final String password) {
         } else {
             mPasswordLayout.setError(null);
         }
-        getDialogHolder().showLoadingDialog(R.string.fui_progress_dialog_signing_in);
 
-        final AuthCredential authCredential = ProviderUtils.getAuthCredential(mIdpResponse);
+        AuthCredential authCredential = ProviderUtils.getAuthCredential(mIdpResponse);
+        mHandler.startSignIn(email, password, mIdpResponse, authCredential);
+    }
 
-        final IdpResponse response;
-        if (authCredential == null) {
-            response = new IdpResponse.Builder(
-                    new User.Builder(EmailAuthProvider.PROVIDER_ID, email).build())
-                    .build();
-        } else {
-            response = new IdpResponse.Builder(mIdpResponse.getUser())
-                    .setToken(mIdpResponse.getIdpToken())
-                    .setSecret(mIdpResponse.getIdpSecret())
-                    .build();
+    @Override
+    public void onClick(View view) {
+        final int id = view.getId();
+        if (id == R.id.button_done) {
+            validateAndSignIn();
+        } else if (id == R.id.trouble_signing_in) {
+            onForgotPasswordClicked();
         }
-
-        // Sign in with known email and the password provided
-        getAuthHelper().getFirebaseAuth()
-                .signInWithEmailAndPassword(email, password)
-                .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
-                    @Override
-                    public void onSuccess(AuthResult authResult) {
-                        // If authCredential is null, the user only has an email account.
-                        // Otherwise, the user has an email account that we need to link to an idp.
-                        if (authCredential == null) {
-                            saveCredentialsOrFinish(
-                                    mSaveSmartLock,
-                                    authResult.getUser(),
-                                    password,
-                                    response);
-                        } else {
-                            authResult.getUser()
-                                    .linkWithCredential(authCredential)
-                                    .continueWithTask(new ProfileMerger(response))
-                                    .addOnFailureListener(new TaskFailureLogger(
-                                            TAG, "Error signing in with credential " +
-                                            authCredential.getProvider()))
-                                    .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
-                                        @Override
-                                        public void onSuccess(AuthResult authResult) {
-                                            saveCredentialsOrFinish(
-                                                    mSaveSmartLock,
-                                                    authResult.getUser(),
-                                                    response);
-                                        }
-                                    });
-                        }
-                    }
-                })
-                .addOnFailureListener(
-                        new TaskFailureLogger(TAG, "Error signing in with email and password"))
-                .addOnFailureListener(this, new OnFailureListener() {
-                    @Override
-                    public void onFailure(@NonNull Exception e) {
-                        getDialogHolder().dismissDialog();
-                        String error = e.getLocalizedMessage();
-                        mPasswordLayout.setError(error);
-                    }
-                });
     }
 }

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

@@ -0,0 +1,77 @@
+package com.firebase.ui.auth.util;
+
+import android.net.Uri;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.RestrictTo;
+import android.text.TextUtils;
+
+import com.firebase.ui.auth.IdpResponse;
+import com.firebase.ui.auth.util.data.ProviderUtils;
+import com.google.android.gms.auth.api.credentials.Credential;
+import com.google.firebase.auth.FirebaseUser;
+
+/**
+ * Utility class for working with {@link Credential} objects.
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class CredentialsUtil {
+
+    /**
+     * Build a credential for the specified {@link FirebaseUser} with optional
+     * password and {@link IdpResponse}.
+     *
+     * See {@link #buildCredential(String, String, String, String, IdpResponse)}.
+     */
+    public static Credential buildCredential(@NonNull FirebaseUser user,
+                                             @Nullable String password,
+                                             @Nullable IdpResponse idpResponse) {
+        String name = user.getDisplayName();
+        String email = user.getEmail();
+        String profilePicturUri = user.getPhotoUrl() != null
+                ? user.getPhotoUrl().toString()
+                : null;
+
+        return buildCredential(email, password, name, profilePicturUri, idpResponse);
+    }
+
+    /**
+     * Build the appropriate credential for the user information passed.
+     *
+     * If the credential cannot be built (for example, empty email) then
+     * will return {@code null}.
+     */
+    @Nullable
+    public static Credential buildCredential(@Nullable String email,
+                                             @Nullable String password,
+                                             @Nullable String name,
+                                             @Nullable String profilePictureUri,
+                                             @Nullable IdpResponse idpResponse) {
+        if (TextUtils.isEmpty(email)) {
+            return null;
+        }
+
+        Credential.Builder builder = new Credential.Builder(email);
+        builder.setPassword(password);
+        if (password == null && idpResponse != null) {
+            String translatedProvider =
+                    ProviderUtils.providerIdToAccountType(idpResponse.getProviderType());
+            if (translatedProvider != null) {
+                builder.setAccountType(translatedProvider);
+            } else {
+                return null;
+            }
+        }
+
+        if (name != null) {
+            builder.setName(name);
+        }
+
+        if (profilePictureUri != null) {
+            builder.setProfilePictureUri(Uri.parse(profilePictureUri));
+        }
+
+        return builder.build();
+    }
+
+}