In this screen, you’ll be asked for information related to the application like App name, logo, privacy policy URL, etc. Be careful with what information you provide because it’ll be shown to the users trying to sign in to the application.

Once you’re done with the OAuth consent screen, navigate to the Credentials screen from the left navigation menu. Here we need to create two OAuth client IDs of Android and Web type.

To create an Android OAuth client ID, you must provide the application package name and the SHA-1 key. It’s important to note that SHA-1 keys are specific to each build type. If you provide the SHA-1 key for the debug variant, the OAuth client ID will only work with debug builds. Therefore, make sure to generate Android client IDs that align with your build requirements.

Next, create a web application client ID. You can skip the “Authorized JavaScript Origins” and “Authorized redirect URIs” fields for now. This client ID will be used to identify your backend server when it communicates with Google’s authentication services.

Copy the web application client ID into your project as we need it to authenticate the user.

Integration

Now that we’re done with project configuration, the next step is integration. In the app-level gradle file add the following libraries under the dependencies node:

// Google SignIn
implementation "androidx.credentials:credentials:1.2.2"
implementation "androidx.credentials:credentials-play-services-auth:1.2.2"
implementation "com.google.android.libraries.identity.googleid:googleid:1.1.0"

Google Sign-In Request

Credential Manager provides two approaches to sign-in the user:

1. GetGoogleIdOption : This is used when you want to have customer UI for the entry point of the Sign-In flow.
2. Google button flow: Well the name itself describes the purpose.

Let’s start by creating a Google sign-in request using GetGoogleIdOption and CredentialManager where we use the web client that was created in the API console. We’ll create a singleton class with the name GoogleSignInManager to keep things simple. Have a look:

object GoogleSignInManager {

    private lateinit var credentialManager: CredentialManager

    suspend fun googleSignIn(
        context: Context,
        clientId: String,
    ) {

        if (::credentialManager.isInitialized.not()) {
            credentialManager = CredentialManager
                .create(context)
        }

        val googleIdOption: GetGoogleIdOption = GetGoogleIdOption
            .Builder()
            .setFilterByAuthorizedAccounts(true)
            .setServerClientId(clientId)
            .setAutoSelectEnabled(false)
            .build()

        val request: GetCredentialRequest = GetCredentialRequest
            .Builder()
            .addCredentialOption(googleIdOption)
            .build()
    }
}

First, check if the user has previously signed in by calling the API with setFilterByAuthorizedAccounts set to true. If authorized accounts are found, the user can choose one to sign in.

private suspend fun requestSignIn(
        context: Context,
        request: GetCredentialRequest,
) {
      try {
        val result = credentialManager.getCredential(
            request = request,
             context = context,
        )
    } catch (e: Exception){
        e.printStackTrace()
    }
}

If no authorized accounts are available, the request will throw NoCredentialException, then we need to prompt the user to sign in with any of their available accounts by calling the API again setFilterByAuthorizedAccounts set to false. That means we need to add a boolean parameter to googleSignIn the function indicating the status of setFilterByAuthorizedAccounts.

Along with filterByAuthorizedAccounts the parameter, we’ll also add two more lambdas doOnSuccess and doOnError which are supposed to be actions performed under respective circumstances. Have a look:

object GoogleSignInManager {

    private lateinit var credentialManager: CredentialManager

    suspend fun googleSignIn(
        context: Context,
        clientId: String,
        filterByAuthorizedAccounts: Boolean,
        doOnSuccess: (String) -> Unit,
        doOnError: (Exception) -> Unit,
    ) {
        if (::credentialManager.isInitialized.not()) {
            credentialManager = CredentialManager
                .create(context)
        }

        val googleIdOption: GetGoogleIdOption = GetGoogleIdOption
            .Builder()
            .setFilterByAuthorizedAccounts(true)
            .setServerClientId(clientId)
            .setAutoSelectEnabled(false)
            .build()

        val request: GetCredentialRequest = GetCredentialRequest
            .Builder()
            .addCredentialOption(googleIdOption)
            .build()

        requestSignIn(
            context, 
            request, 
            clientId, 
            filterByAuthorizedAccounts, 
            doOnSuccess, 
            doOnError
        )
    }

    private suspend fun requestSignIn(
        context: Context,
        request: GetCredentialRequest,
        clientId: String,
        filterByAuthorizedAccounts: Boolean,
        doOnSuccess: (String) -> Unit,
        doOnError: (Exception) -> Unit,
    ) {
        try {
            val result = credentialManager.getCredential(
                request = request,
                context = context,
            )
            doOnSuccess("")
        } catch (e: Exception){
            if (e is NoCredentialException && filterByAuthorizedAccounts) {
                googleSignIn(
                    context, 
                    clientId, 
                    false,
                    doOnSuccess,
                    doOnError
                )
            } else {
                doOnError(e)
            }
        }
    }
}

Let’s go through the code one last time, googleSignIn is the function that’s responsible for creating necessary objects with the input states, then it’ll trigger requestSignIn function which is responsible for initiating the request via CredentialManager and triggering doOnSuccess or doOnError based on the result.