Trigger listener events in Auth right after it is registered.

Also make sure it only triggers immediate if the persistent cache is loaded.

PiperOrigin-RevId: 246345230

Author: chkuang-g

auth/src/auth.cc

@@ -192,8 +192,9 @@ static bool PushBackIfMissing(const T& entry, std::vector<T>* v) {
 // Store a unique listener of type T in a listener_vector and unique auth
 // object in auth_vector.  Both vectors must be in sync, i.e addition must
 // either succeed or fail otherwise this method asserts.
+// Return whether the listener is added.
 template <typename T>
-static void AddListener(T listener, std::vector<T>* listener_vector, Auth* auth,
+static bool AddListener(T listener, std::vector<T>* listener_vector, Auth* auth,
                         std::vector<Auth*>* auth_vector, Mutex* mutex) {
   MutexLock lock(*mutex);
   // Add to array of listeners if not already there.
@@ -203,26 +204,38 @@ static void AddListener(T listener, std::vector<T>* listener_vector, Auth* auth,
 
   // The listener and Auth should either point at each other or not point
   // at each other.
-  FIREBASE_ASSERT_RETURN_VOID(listener_added == auth_added);
+  FIREBASE_ASSERT_RETURN(false, listener_added == auth_added);
   (void)auth_added;
-  (void)listener_added;
+
+  return listener_added;
 }
 
 void Auth::AddAuthStateListener(AuthStateListener* listener) {
   if (!auth_data_) return;
-  AddListener(listener, &auth_data_->listeners, this, &listener->auths_,
-              &auth_data_->listeners_mutex);
+  bool added = AddListener(listener, &auth_data_->listeners, this,
+                           &listener->auths_, &auth_data_->listeners_mutex);
+  // If the listener is registered successfully and persistent cache has been
+  // loaded, trigger OnAuthStateChanged() immediately.  Otherwise, wait until
+  // the cache is loaded, through AuthStateListener event
+  if (added && auth_data_->persistent_cache_loaded) {
+    listener->OnAuthStateChanged(this);
+  }
 }
 
 void Auth::AddIdTokenListener(IdTokenListener* listener) {
   if (!auth_data_) return;
-  int listener_count = auth_data_->id_token_listeners.size();
-  AddListener(listener, &auth_data_->id_token_listeners, this,
-              &listener->auths_, &auth_data_->listeners_mutex);
+  bool added = AddListener(listener, &auth_data_->id_token_listeners, this,
+                           &listener->auths_, &auth_data_->listeners_mutex);
   // AddListener is valid even if the listener is already registered.
   // This makes sure that we only increase the reference count if a listener
   // was actually added.
-  if (auth_data_->id_token_listeners.size() > listener_count) {
+  if (added) {
+    // If the listener is registered successfully and persistent cache has been
+    // loaded, trigger OnAuthStateChanged() immediately.  Otherwise, wait until
+    // the cache is loaded, through AuthStateListener event
+    if (auth_data_->persistent_cache_loaded) {
+      listener->OnIdTokenChanged(this);
+    }
     EnableTokenAutoRefresh(auth_data_);
   }
 }
@@ -321,10 +334,15 @@ static inline bool VectorContains(const T& entry, const std::vector<T>& v) {
       /* Notify the listener. */                                               \
       listener->notification_method(auth_data->auth);                          \
     }                                                                          \
+                                                                               \
+    /* Auth should have loaded persistent cache if exists when the listener */ \
+    /* event is triggered for the first time. */                               \
+    auth_data->persistent_cache_loaded = true;                                 \
   }
 
 AUTH_NOTIFY_LISTENERS(NotifyAuthStateListeners, "Auth state", listeners,
                       OnAuthStateChanged);
+
 AUTH_NOTIFY_LISTENERS(NotifyIdTokenListeners, "ID token", id_token_listeners,
                       OnIdTokenChanged);
 

auth/src/data.h

@@ -78,7 +78,8 @@ struct AuthData {
         user_impl(nullptr),
         listener_impl(nullptr),
         id_token_listener_impl(nullptr),
-        expect_id_token_listener_callback(false) {}
+        expect_id_token_listener_callback(false),
+        persistent_cache_loaded(false) {}
 
   ~AuthData() {
     ClearUserInfos(this);
@@ -155,6 +156,9 @@ struct AuthData {
   // Tracks if the Id Token listener is expecting a callback to occur.
   bool expect_id_token_listener_callback;
 
+  // Tracks if the persistent cache has been loaded.
+  bool persistent_cache_loaded;
+
   // Mutex protecting `expect_id_token_listener_callback`
   Mutex expect_id_token_mutex;
 

auth/src/include/firebase/auth.h

@@ -137,10 +137,17 @@ class Auth {
   ~Auth();
 
   /// Synchronously gets the cached current user, or nullptr if there is none.
+  /// Current user might not be available immediately after Auth is created, if
+  /// a user has signed in before. It is recommended to use AuthStateListener as
+  /// the source of truth whether a user has logged in or not.
   /// <SWIG>
   /// @xmlonly
   /// <csproperty name="CurrentUser">
   /// Synchronously gets the cached current user, or null if there is none.
+  /// CurrentUser might not be available immediately after FirebaseAuth is
+  /// created, if a user has signed in before. It is recommended to use
+  /// StateChanged delegate as the source of truth whether a user has logged in
+  /// or not.
   /// </csproperty>
   /// @endxmlonly
   /// </SWIG>
@@ -399,6 +406,7 @@ class Auth {
   /// The listeners are called asynchronously, possibly on a different thread.
   ///
   /// Authentication state changes are:
+  ///   - Right after the listener has been registered
   ///   - When a user signs in
   ///   - When the current user signs out
   ///   - When the current user changes
@@ -430,6 +438,7 @@ class Auth {
   /// The listeners are called asynchronously, possibly on a different thread.
   ///
   /// Authentication state changes are:
+  ///   - Right after the listener has been registered
   ///   - When a user signs in
   ///   - When the current user signs out
   ///   - When the current user changes
@@ -526,6 +535,7 @@ class AuthStateListener {
   virtual ~AuthStateListener();
 
   /// Called when the authentication state of `auth` changes.
+  ///   - 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
@@ -558,6 +568,11 @@ class IdTokenListener {
   virtual ~IdTokenListener();
 
   /// Called when there is a change in the current user's token.
+  ///   - Right after the listener has been registered
+  ///   - When a user signs in
+  ///   - When the current user signs out
+  ///   - When the current user changes
+  ///   - When there is a change in the current user's token
   ///
   /// @param[in] auth Disambiguates which @ref Auth instance the event
   /// corresponds to, in the case where you are using more than one at the same