如何在Firebase中实现iPhone应用活跃用户45分钟无操作自动转非活跃？

Absolutely, this is totally achievable with Firebase combined with iOS native lifecycle and event handling! Let’s break down exactly how to implement this requirement step by step.

First off, yes—you don’t need to force logout users to switch their status from active to inactive after 45 minutes of inactivity. The core approach combines:

• iOS app lifecycle/event listeners to track user interaction
• Firebase (Firestore or Realtime Database) to store and sync user state and last activity timestamps

1. Define User State Structure in Firebase #

First, set up a user data structure in your Firebase database (we’ll use Firestore here as an example) to track two key fields:

• isActive: A boolean flag marking whether the user is currently active
• lastActiveTimestamp: A timestamp recording the user’s most recent interaction

Example Firestore user document:

// Firestore users collection document example
{
  uid: "user_123abc",
  email: "user@example.com",
  isActive: true,
  lastActiveTimestamp: Timestamp.fromDate(Date())
}

2. Track User Interaction & App Lifecycle on iOS #

You need to listen for two types of events on iOS to detect inactivity:

• App foreground/background transitions
• User interactions within the app (taps, swipes, etc.)

Listen to App Lifecycle Events #

Add these handlers to your SceneDelegate (or AppDelegate for older iOS versions):

func sceneDidBecomeActive(_ scene: UIScene) {
    // App came to foreground—mark user as active and update last activity time
    updateUserActiveStatus(isActive: true)
    // Reset the inactivity timer since user is engaging with the app
    resetInactivityTimer()
}

func sceneDidEnterBackground(_ scene: UIScene) {
    // App went to background—start the 45-minute timer to check inactivity
    startInactivityTimer()
}

Track In-App User Interactions #

To catch when a user is active in the app but not switching foreground/background, add a global gesture recognizer to your app’s window to detect taps (you can extend this to other gestures like swipes if needed):

func setupGlobalInteractionListener() {
    let tapGesture = UITapGestureRecognizer(target: self, action: #selector(userDidInteract))
    tapGesture.cancelsTouchesInView = false // Don't interfere with other UI gestures
    window?.addGestureRecognizer(tapGesture)
}

@objc private func userDidInteract() {
    // User performed an action—update last activity and reset the timer
    updateUserActiveStatus(isActive: true)
    resetInactivityTimer()
}

3. Implement the Inactivity Timer #

Create a timer that triggers after 45 minutes of no interaction. When it fires, check if enough time has passed and switch the user’s status if needed:

private var inactivityTimer: Timer?

private func startInactivityTimer() {
    inactivityTimer?.invalidate() // Cancel any existing timer
    inactivityTimer = Timer.scheduledTimer(withTimeInterval: 45 * 60, repeats: false) { [weak self] _ in
        self?.checkAndSwitchToInactive()
    }
}

private func resetInactivityTimer() {
    inactivityTimer?.invalidate()
    startInactivityTimer()
}

4. Sync State with Firebase #

Implement functions to update and check the user’s status in Firebase:

Update User Active Status #

import FirebaseFirestore
import FirebaseAuth

private func updateUserActiveStatus(isActive: Bool) {
    guard let currentUser = Auth.auth().currentUser else { return }
    let db = Firestore.firestore()
    
    let userRef = db.collection("users").document(currentUser.uid)
    userRef.updateData([
        "isActive": isActive,
        "lastActiveTimestamp": Timestamp(date: Date())
    ]) { error in
        if let error = error {
            print("Failed to update user status: \(error.localizedDescription)")
        }
    }
}

Check & Switch to Inactive Status #

private func checkAndSwitchToInactive() {
    guard let currentUser = Auth.auth().currentUser else { return }
    let db = Firestore.firestore()
    
    db.collection("users").document(currentUser.uid).getDocument { [weak self] document, error in
        guard let document = document, document.exists,
              let lastActive = document.data()?["lastActiveTimestamp"] as? Timestamp else {
            return
        }
        
        let timeSinceLastActivity = Date().timeIntervalSince(lastActive.dateValue())
        // If 45+ minutes have passed since last activity, switch to inactive
        if timeSinceLastActivity >= 45 * 60 {
            self?.updateUserActiveStatus(isActive: false)
        }
    }
}

5. Optional: Sync Status Across Multiple Devices #

If users might be logged in on multiple devices, add a real-time listener to sync the status locally whenever it changes in Firebase:

func setupUserStatusListener() {
    guard let currentUser = Auth.auth().currentUser else { return }
    let db = Firestore.firestore()
    
    db.collection("users").document(currentUser.uid)
        .addSnapshotListener { documentSnapshot, error in
            guard let document = documentSnapshot, let data = document.data() else {
                print("Error fetching user status: \(error?.localizedDescription ?? "Unknown error")")
                return
            }
            let isActive = data["isActive"] as? Bool ?? false
            // Update your app's UI or logic with the latest status
            self.updateLocalUIForActiveStatus(isActive: isActive)
        }
}

• iOS Background Restrictions: iOS may pause background timers to save battery. To handle this, consider using the BackgroundTasks framework to request extra background time to complete the status update.
• Battery Efficiency: Avoid excessive Firebase writes—only update the lastActiveTimestamp when the user interacts with the app, not on every single UI event.
• Auth State Safety: Always check that a user is logged in before attempting to update their status to avoid runtime errors.

内容的提问来源于stack exchange，提问作者Rob Haisfield