Hey there, let's break down this sync problem you're dealing with—it’s super likely tied to authentication token expiration or offline persistence quirks that are blocking your app from syncing with Firestore after an hour of idle time. Here’s what I’d check and fix step by step:

• Expired Google Sign-In Tokens Are the Most Likely Culprit
  Google’s ID tokens for Firebase Auth expire after exactly 1 hour. If your app isn’t automatically refreshing this token when it expires, Firestore loses its authenticated connection to the backend. That means new writes get stuck in the local cache instead of syncing up to the cloud.

  • Most Firebase SDKs handle token refresh automatically, but if you’re manually managing tokens (like passing custom auth headers), you need to add an auth state listener to catch when tokens refresh or become invalid.
  • For example, on Android:

    FirebaseAuth.getInstance().addAuthStateListener { auth ->
        auth.currentUser?.getIdToken(true) // Force a refresh if needed
            ?.addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    // The token’s refreshed—Firestore should automatically use the new credentials, but this confirms it
                }
            }
    }
    

  • For web, make sure you’re using onAuthStateChanged to monitor user state changes. Firestore should automatically pick up the new token, but double-check you haven’t overridden any default auth settings.

• Check Firestore Offline Persistence Behavior
  When the app loses authenticated access, Firestore queues writes locally—but it won’t sync them until the connection is re-authenticated. If your app isn’t detecting when the auth state is restored, those queued writes might stay stuck indefinitely.

  • Offline persistence is enabled by default on mobile, but verify it’s active (and if you’re on web, explicitly enable it if you haven’t). Then add a snapshot listener to monitor sync status:

    // iOS example
    let db = Firestore.firestore()
    db.enablePersistence { error in
        if let error = error {
            print("Persistence setup failed: \(error.localizedDescription)")
        }
    }
    // Listen for when data syncs from the server
    db.collection("your-collection").addSnapshotListener { snapshot, error in
        if let error = error {
            print("Sync error: \(error.localizedDescription)")
        } else {
            if snapshot?.metadata.isFromCache == false {
                print("Successfully synced with cloud!")
            }
        }
    }
    

• Double-Check Your Firestore Security Rules
  You mentioned configuring rules, but they might not handle token refresh scenarios properly. If your rules require request.auth != null (which they should for authenticated writes), an expired token would make request.auth null—blocking writes from syncing until the token refreshes.

  • Test your rules in the Firestore Rules Playground by simulating an unauthenticated request (to mimic an expired token) and see if writes are denied. Here’s a solid base rule for authenticated access:

    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if request.auth != null;
        }
      }
    }
    

• Handle App Background/Foreground Transitions
  Mobile OSs often restrict network access or suspend app processes when the app’s been in the background for an hour. When the app comes back to the foreground, it might not automatically re-authenticate unless you trigger it.

  • Add a lifecycle listener to check auth state when the app resumes. For example, in Flutter:

    WidgetsBinding.instance.addObserver(LifecycleEventHandler(
      resumeCallBack: () async {
        final currentUser = FirebaseAuth.instance.currentUser;
        if (currentUser != null) {
          await currentUser.getIdToken(true); // Force token refresh
          // Trigger a dummy read or write to kick off Firestore sync
        }
      },
    ));
    
    class LifecycleEventHandler extends WidgetsBindingObserver {
      final AsyncCallback resumeCallBack;
    
      LifecycleEventHandler({required this.resumeCallBack});
    
      @override
      void didChangeAppLifecycleState(AppLifecycleState state) {
        if (state == AppLifecycleState.resumed) {
          resumeCallBack();
        }
      }
    }
    

• Force Sync After Token Refresh
  If the SDK isn’t automatically syncing pending writes after a token refresh, you can trigger it manually. A simple way is to read a small document from Firestore—this initiates a network request and tells Firestore to sync any queued local writes.

If you’ve tried all these steps and the issue still persists, check the Firebase Console’s Auth > Logs to see if token refreshes are failing, and Firestore > Usage to look for denied write requests. That should help you pinpoint any remaining issues.

内容的提问来源于stack exchange，提问作者Viktoriia Chebotar