Check if user is authenticated for the first time in Firebase Google Authentication in Android

I am using Firebase Authentication in an Android application, and I am using Google account authentication as an option to sign in to the application.

How can I know if the user is signed in to the application for the first time or not?

To check if it's the first time user logs in, simply call the AdditionalUserInfo.isNewUser() method in the OnCompleteListener.onComplete callback.

Example code below, be sure to check for null.

OnCompleteListener<AuthResult> completeListener = new OnCompleteListener<AuthResult>() {
        @Override
        public void onComplete(@NonNull Task<AuthResult> task) {
            if (task.isSuccessful()) {
                boolean isNew = task.getResult().getAdditionalUserInfo().isNewUser();
                Log.d("MyTAG", "onComplete: " + (isNew ? "new user" : "old user"));
            }
        }
    };

Check the docs for more reference AdditionalUserInfo

From the Firebase-ui docs, you can check the last sign-in timestamp against the created-at timestamp like this:

FirebaseUserMetadata metadata = auth.getCurrentUser().getMetadata();
if (metadata.getCreationTimestamp() == metadata.getLastSignInTimestamp()) {
    // The user is new, show them a fancy intro screen!
} else {
    // This is an existing user, show them a welcome back screen.
}

According to the new version of Firebase auth (16.0.1) The AuthResult class has a member function which results true or false (is the user is new). Assuming "credential" is defined in the scope(it is the google credential ). An example is shown below: `

private FirebaseAuth mAuth;

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id))
            .requestEmail()
            .build();

mAuth = FirebaseAuth.getInstance();
Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data);
GoogleSignInAccount acct = task.getResult(ApiException.class);
AuthCredential credential = GoogleAuthProvider.getCredential(acct.getIdToken(), null);
     
mAuth.signInWithCredential(credential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "linkWithCredential:success");
                        

                        boolean newuser = task.getResult().getAdditionalUserInfo().isNewUser();
                         
 
                        
                        if(newuser){

                             //Do Stuffs for new user

                         }else{

                            //Continue with Sign up 
                        }
                        
                    } else {
                        
                        Toast.makeText(MyClass.this, "Authentication failed.",
                                Toast.LENGTH_SHORT).show();
                        
                    }

               
            });

Thanks to firebase:)

From version 11.6.0 we can use AdditionalUserInfo.isNewUser()

https://firebase.google.com/docs/reference/android/com/google/firebase/auth/AdditionalUserInfo

A solution when you use Firebase Auth together with Firestore

The root architecture of the Firestore Database would look like this

Use the Firebase Auth currentUser.uid to create a root document for each user. Start by adding a field called registered_at to the root document as soon as the user is created the first time and then add your specific collections to your root document depending on your use case.

When logging in or signing in you can then check if the document with the registered_at field already exists. If it doesn't exist yet, then you can treat the user as a new user (assuming the user can not delete or alter the registered_at field later)

import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.firestore.DocumentReference
import com.google.firebase.firestore.FirebaseFirestore

fun rootDocument(): DocumentReference? = rootPath()?.let {
    return fireStore().document(it)
}

fun rootPath(): String? {
    val loggedInUser = loggedInUser()
    if (loggedInUser != null) {
        return "users/${loggedInUser.uid}"
    }
    return null
}

fun fireStore() = FirebaseFirestore.getInstance()

fun createWriteBatch() = fireStore().batch()

fun loggedInUser() = fireAuth().currentUser

fun fireAuth(): FirebaseAuth = FirebaseAuth.getInstance()

fun afterSignIn() {

    val rootDocument = rootDocument()
            ?: throw IllegalStateException("root document not found")

    rootDocument.get().addOnCompleteListener {
        val isNewUser = it.result.exists().not()

        if (isNewUser) {
            val batch = createWriteBatch()

            batch.set(rootDocument, HashMap<Any, Any>().apply {
                put("registered_at", System.currentTimeMillis())
            })

            batch.commit().addOnCompleteListener {
                println("this is a new user")
            }

        } else {
            println("this is not a new user")
        }
    }
}

While I fully agree that the most correct way (given the inability to add new fields to the auth user table) is to create a new path for users and store info there, I didn't want to make an additional request after logging in to do this check (I'm using Firestore and requests = money).

I needed to do this first login check to prompt for a userName (as display name is pulled from Facebook/Google and I wanted to give the option of overriding if it's their first login). What I ended up doing was using the photoURL property as a flag to determine if it was their first time or not. It's not ideal but maybe someone that wants to save on requests can use this as a workaround. It's not as big a deal for Firebase but for Firestore it's more costly for your plan

In Firebase UI, JAVA:

 @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Intent i;


        if (requestCode == RC_SIGN_IN) {
            IdpResponse response = IdpResponse.fromResultIntent(data);

            if (resultCode == RESULT_OK) {


                if(response.isNewUser()){
                Log.d(TAG, "onActivityResult: isNewUser "+response.isNewUser());
} else {

                // Successfully signed in
                }

                // ...
            } else {



//               handle error
            }
        }
    }

Workaround I used-

1. Created a collection in Firestore named 'Users'.
2. Whenever someone signs in, get its uid
3. Search for that uid in the 'Users'. Make sure to name 'Users' documents = user's UID.
4. If the document exists, then its the new user, if it doesn't
5. then add that particular user's doc in that collection 'Users'.

Trick Used - Use UID to solve this problem. Thanks, upvote if helpful

For Web, version 9.0 (modular):

You will need to import "getAdditionalUserInfo" and call it as such:

signInWithPopup(firebaseAuth, provider)
  .then((result) => {
    const details = getAdditionalUserInfo(result)
    console.log(details)
  })
  .catch((error) => {
    console.log(error);
  });

The details returned includes an "isNewUser" boolean property.

Details on GitHub from August 2021

This may help you and try it:

https://stackoverflow.com/questions/35285856/correct-code-location-to-check-firebase-if-a-user-has-been-created-already

First of all Check - if current user uid match with your documents id then it's old user otherwise it's new user

> Example

private boolean isUserMatch(String currentUserId) {
    firestore.collection(COLLECTION_USER).get().addOnCompleteListener(new OnCompleteListener< QuerySnapshot >() {
        @Override
        public void onComplete(@NonNull @NotNull Task< QuerySnapshot > task) {
            if (task.isSuccessful()) {
                for (QueryDocumentSnapshot documentSnapshot : task.getResult()) {
                    if (currentUserId.equals(documentSnapshot.getId())) {
                        return;
                    }
                }
            }
        }
    }).addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull @NotNull Exception e) {
            Log.e(TAG, "onFailure: ", e.getCause());
        }
    });
    return false;
}