import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
/**
 * Begin the process of retrieving a {@link Credential} for the device user. This can have
 * a few different results:
 *   1) If the user has auto sign-in enabled and exactly one previously saved credential,
 *      {@link SmartLockListener#onCredentialRetrieved(Credential)} will be called and
 *      you can sign the user in immediately.
 *   2) If the user has multiple saved credentials or one saved credential and has disabled
 *      auto sign-in, you will get the callback {@link SmartLockListener#onShouldShowCredentialPicker()}
 *      at which point you can choose to show the picker dialog to continue.
 *   3) If the user has no saved credentials or cancels the operation, you will receive the
 *      {@link SmartLockListener#onCredentialRetrievalFailed()} callback.
 */
public void getCredentials() {
    CredentialRequest request = buildCredentialRequest();

    Auth.CredentialsApi.request(getFragment().getGoogleApiClient(), request)
            .setResultCallback(new ResultCallback<CredentialRequestResult>() {
                @Override
                public void onResult(CredentialRequestResult result) {
                    if (result.getStatus().isSuccess()) {
                        // Single credential, auto sign-in
                        Credential credential = result.getCredential();
                        getListener().onCredentialRetrieved(credential);
                    } else if (result.getStatus().hasResolution() &&
                            result.getStatus().getStatusCode() != CommonStatusCodes.SIGN_IN_REQUIRED) {
                        // Multiple credentials or auto-sign in disabled.  If the status
                        // code is SIGN_IN_REQUIRED then it is a hint credential, which we
                        // do not want at this point.
                        getListener().onShouldShowCredentialPicker();
                    } else {
                        // Could not retrieve credentials
                        getListener().onCredentialRetrievalFailed();
                    }
                }
            });
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
/**
 * Show the dialog allowing the user to choose a Credential. This method shoud only be called
 * after you receive the {@link SmartLockListener#onShouldShowCredentialPicker()} callback.
 */
public void showCredentialPicker() {
    CredentialRequest request = buildCredentialRequest();
    Activity activity = getFragment().getActivity();
    int maskedCode = getFragment().maskRequestCode(RC_READ);

    Auth.CredentialsApi.request(getFragment().getGoogleApiClient(), request)
            .setResultCallback(new ResolvingResultCallbacks<CredentialRequestResult>(activity, maskedCode) {
                @Override
                public void onSuccess(CredentialRequestResult result) {
                    getListener().onCredentialRetrieved(result.getCredential());
                }

                @Override
                public void onUnresolvableFailure(Status status) {
                    Log.e(TAG, "showCredentialPicker:onUnresolvableFailure:" + status);
                }
            });
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
private CredentialRequest buildCredentialRequest() {
    return new CredentialRequest.Builder()
            .setCredentialPickerConfig(new CredentialPickerConfig.Builder()
                .setShowAddAccountButton(false)
                .setShowCancelButton(true)
                .setForNewAccount(false)
                .build())
            .setPasswordLoginSupported(true)
            .build();
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
@Override
public void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstance);
    if (savedInstance != null) {
        // We already have a running instance of this fragment
        return;
    }

    FlowParameters flowParams = getFlowParams();
    if (flowParams.enableCredentials) {
        getDialogHolder().showLoadingDialog(R.string.fui_progress_dialog_loading);

        mGoogleApiClient = new GoogleApiClient.Builder(getContext().getApplicationContext())
                .addConnectionCallbacks(this)
                .addApi(Auth.CREDENTIALS_API)
                .enableAutoManage(getActivity(), GoogleApiHelper.getSafeAutoManageId(), this)
                .build();
        mGoogleApiClient.connect();

        getAuthHelper().getCredentialsApi()
                .request(mGoogleApiClient,
                        new CredentialRequest.Builder()
                                .setPasswordLoginSupported(true)
                                .setAccountTypes(getSupportedAccountTypes().toArray(new String[0]))
                                .build())
                .setResultCallback(this);
    } else {
        startAuthMethodChoice();
    }
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
@Test
public void shouldClearItselfOnStop() throws Exception {
    doCallRealMethod().when(smartLock).startTask(eq(task));
    smartLock.setCallback(callback);
    smartLock.startTask(task);
    smartLock.onStop();
    assertThat(smartLock.credentialRequest, is(nullValue(CredentialRequest.class)));
    assertThat(smartLock.currentTask(), is(nullValue(GoogleApiClientConnectTask.class)));
    assertThat(smartLock.getCallback(), notNullValue(CredentialStoreCallback.class));
    verifyCallbackIsCleaned();
    verify(task).cancel(false);
    verify(googleApiClient).disconnect();
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
/**
 * Request option 1: https://developers.google.com/identity/smartlock-passwords/android/overview
 */
private void attemptRequestCredentials() {
    if (mIsResolving) {
        return;
    }

    mNeedToRequestCredentials = true;
    mLoginButton.setText(getString(R.string.retrieving_credentials));

    CredentialRequest request = new CredentialRequest.Builder()
            .setSupportsPasswordLogin(true)
            .build();

    if (mGoogleApiClient.isConnected()) {
        Auth.CredentialsApi.request(mGoogleApiClient, request).setResultCallback(
                credentialRequestResult -> {
                    finishAllLoading();
                    final Status status = credentialRequestResult.getStatus();
                    if (status.isSuccess()) {
                        // Single credential and auto sign-in enabled.
                        //Request 2
                        processRetrievedCredential(credentialRequestResult.getCredential(), false);
                    } else if (status.getStatusCode() == CommonStatusCodes.RESOLUTION_REQUIRED) {
                        // Multiple credentials - pick one
                        //Request 3
                        resolveResult(status, RC_READ);
                    } else if (status.getStatusCode() == CommonStatusCodes.SIGN_IN_REQUIRED) {
                        loadHints();
                    }
                });
        mNeedToRequestCredentials = false;
    }
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
public void setCredentialRequest(CredentialRequest credentialRequest) {
    mCredentialRequest = credentialRequest;
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
public Builder(FragmentActivity activity) {
    this.activity = activity;
    credentialRequestBuilder = new CredentialRequest.Builder();
    // at least one provider (mandatory)
    credentialRequestBuilder.setAccountTypes(IdentityProviders.GOOGLE);
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
private void requestCredentials() {
        mSignInButton.setEnabled(false);
        mIsRequesting = true;

        CredentialRequest request = new CredentialRequest.Builder()
                .setPasswordLoginSupported(true)
                .setAccountTypes(IdentityProviders.GOOGLE, IdentityProviders.TWITTER)
                .build();

        Auth.CredentialsApi.request(mGoogleApiClient, request).setResultCallback(
                new ResultCallback<CredentialRequestResult>() {
                    @Override
                    public void onResult(CredentialRequestResult credentialRequestResult) {
//                        mIsRequesting = false;
                        Status status = credentialRequestResult.getStatus();
                        if (credentialRequestResult.getStatus().isSuccess()) {
                            // Successfully read the credential without any user interaction, this
                            // means there was only a single credential and the user has auto
                            // sign-in enabled.
                            Credential credential = credentialRequestResult.getCredential();
                            processRetrievedCredential(credential);
                        } else if (status.getStatusCode() == CommonStatusCodes.RESOLUTION_REQUIRED) {
//                            setFragment(null);
                            // This is most likely the case where the user has multiple saved
                            // credentials and needs to pick one.
                            resolveResult(status, RC_READ);
                        } else if (status.getStatusCode() == CommonStatusCodes.SIGN_IN_REQUIRED) {
//                            setFragment(null);
                            // This is most likely the case where the user does not currently
                            // have any saved credentials and thus needs to provide a username
                            // and password to sign in.
                            Log.d(TAG, "Sign in required");
                            mSignInButton.setEnabled(true);
                        } else {
                            Log.w(TAG, "Unrecognized status code: " + status.getStatusCode());
//                            setFragment(null);
                            mSignInButton.setEnabled(true);
                        }
                    }
                }
        );
    }
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
public void requestCredentials(ResultCallback<? super CredentialRequestResult> callback) {
    Auth.CredentialsApi.request(client, new CredentialRequest.Builder()
            .setPasswordLoginSupported(true)
            .setAccountTypes(IdentityProviders.GOOGLE)
            .build()).setResultCallback(callback);
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
@NonNull CredentialRequest newCredentialRequest() {
    credentialRequest = new CredentialRequest.Builder()
            .setSupportsPasswordLogin(true)
            .build();
    return credentialRequest;
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
public RetrieveCredentialObservable(Context context, CredentialRequest request) {
    mContext = context;
    mCredentialRequest = request;
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
public Builder(Context context) {
    mContext = context;
    mCredentialRequestBuilder = new CredentialRequest.Builder();
}
 

import com.google.android.gms.auth.api.credentials.CredentialRequest; //导入依赖的package包/类
private CredentialRequest.Builder getCredentialRequestBuilder() {
    return mCredentialRequestBuilder;
}