Firebase Android onAuthStateChanged called twice

Yes, and this is very annoying. This is due a registration call. Not only that, onAuthStateChanged is going to be called many times in many different states, with no possibility of knowing which state it is.

Documentation says:

onAuthStateChanged(FirebaseAuth auth)

This method gets invoked in the UI thread on changes in the authentication state:

• Right after the listener has been registered

• When a user is signed in

• When the current user is signed out

• When the current user changes

• When there is a change in the current user's token

Here some tips to discover the current state:

• Registration call: skip the first call with a flag.
• User signed in: user from parameter is != null.
• User signed out: user from parameter is == null.
• Current user changes: user from parameter is != null and last user id is != user id from parameter
• User token refresh: user from parameter is != null and last user id is == user id from parameter

This listener is a mess and very bugprone. Firebase team should look into it.

While the other answers provided here might do the job, I find managing a flag cumbersome and error-prone.

I prefer debouncing the event within short periods of time. It is very unlikely, maybe even impossible, for a user to login then logout within a period of 200ms let's say.

TLDR

Debouncing means that before handling an event, you wait to see if the same event is gonna fire again within a predefined period of time. If it did, you reset the timer and wait again. If it didn't, you handle the event.

This is an Android question, which is not my field, but I'm sure android provides some kind of tool that can help with the task. If not, you can make one using a simple timer.

Here's how a Javascript implementation might look like:

var debounceTimeout;
const DebounceDueTime = 200; // 200ms

function onAuthStateChanged(auth)
{
    if (debounceTimeout)
        clearTimeout(debounceTimeout);

    debounceTimeout = setTimeout(() =>
    {
        debounceTimeout = null;

        handleAuthStateChanged(auth);
    }, DebounceDueTime);
}

function handleAuthStateChanged(auth)
{
    // ... process event
}

My workaround is to use a Boolean declared globally to flag if onAuthStateChanged has need called before.

private Boolean authFlag = false;
 mAuthListener = new FirebaseAuth.AuthStateListener() {
        @Override
        public void onAuthStateChanged(@NonNull final FirebaseAuth firebaseAuth) {
            if (firebaseAuth.getCurrentUser() != null) {
                if(authFlag== false) {
                    // Task to perform once
                    authFlag=true;
                }
            }
        }
    };

Usually I want to setup the UI before adding the listener and repeat the setup any time the auth state changes (avoiding the initial double call). My solution is to enhance the boolean flag solution and keep track of the uid (not the token) of the last user, which may be null.

private FirebaseAuth firebaseAuth;
private String lastUid; // keeps track of login status and changes thereof

In onCreate, I get the auth instance and set the UI accordingly, before adding the listener in onStart

@Override
protected void onCreate(Bundle savedInstanceState){
    ...
    firebaseAuth = FirebaseAuth.getInstance();
    getUserSetUI();
    ...
}

where getUserSetUI sets lastUid according to the auth instance

private void getUserSetUI(){
    lastUid = (firebaseAuth == null || firebaseAuth.getCurrentUser() == null) ?
            null : firebaseAuth.getUid();
    setUI(!(lastUid == null));
}

The listener checks to see if the state has actually changed

@Override
public void onAuthStateChanged(@NonNull FirebaseAuth auth){
    String uid = auth.getUid(); // could be null
    if( (uid == null && lastUid != null) || // loggedout
            (uid != null && lastUid == null) || // loggedin
            (uid != null && lastUid != null && // switched accounts (unlikely)
                    !uid.equals(lastUid))){
        getUserSetUI();
    }
}

if (authStateListener == null) {
        authStateListener = new FirebaseAuth.AuthStateListener() {
            @Override
            public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
                if (firebaseAuth.getCurrentUser() == null) {
                    //Do anything here which needs to be done after signout is complete
                    FirebaseAuth.getInstance().removeAuthStateListener(this);
                    Log.d(TAG_, "logout");


                    finish();
                } else {
                }
            }
        };
    }

FirebaseAuth.getInstance().removeAuthStateListener(this) should be called

  try{
       FirebaseAuth.getInstance().signOut();
       FirebaseInstanceId.getInstance().deleteInstanceId();
   }catch (Exception ex){
       ex.printStackTrace();
   }

When user logout from gmail then the user should also be logout from firebase. This is how I resolved this issue.