如何在Firebase Database中优化保存FCM令牌以避免重复？

Great question! Storing FCM tokens without duplicates is key to preventing redundant notifications and keeping your Firebase Database clean. Let’s walk through practical solutions, including whether Firebase Functions can help with deduplication.

1. Use the FCM Token or Device ID as the Node Key (Client-Side Fix) #

The simplest and most efficient way to avoid duplicates is to replace the push() generated ID with a unique identifier tied to the token or device. Here are two solid approaches:

Option A: Use the FCM Token itself as the key #

Since FCM tokens are unique per device-instance, you can store each token as a direct child under users/{user.uid}/tokens, using the token string as the key. This way, if the same token is saved again, it will overwrite the existing entry instead of creating a new one.

Example code (Kotlin):

val tokenRef = FirebaseDatabase.getInstance().reference
    .child("users/${user.uid}/tokens")
    .child(token) // Use the token as the key
tokenRef.setValue(true) // Value can be a boolean, or metadata like timestamp

Option B: Use a Device Unique ID as the key #

Even better, use a persistent device ID (like Android's ANDROID_ID or iOS's identifierForVendor) as the key. This ensures each device only has one active token stored—when the token updates (which can happen for various reasons), you’ll overwrite the old token instead of leaving stale entries cluttering your database.

Example code (Kotlin):

// First, implement a method to get your app's unique device ID
fun getDeviceUniqueId(): String {
    // Android example: Settings.Secure.ANDROID_ID (handle permissions if needed)
    // iOS example: UIDevice.current.identifierForVendor?.uuidString
    return "your-device-unique-id"
}

// Then save the token using the device ID as the key
val deviceId = getDeviceUniqueId()
val tokenRef = FirebaseDatabase.getInstance().reference
    .child("users/${user.uid}/tokens")
    .child(deviceId)
tokenRef.setValue(token)

2. Using Firebase Functions for Deduplication #

Yes, you can use Firebase Functions to clean up duplicates, though this is a secondary approach (since client-side fixes are more efficient). This is useful if you can’t modify client code, or need server-side validation.

You’ll create a Realtime Database onCreate trigger that checks for duplicate tokens under the user’s tokens node and removes duplicates when a new entry is added.

Example Cloud Function (JavaScript):

const functions = require("firebase-functions");
const admin = require("firebase-admin");
admin.initializeApp();

exports.removeDuplicateTokens = functions.database
    .ref("/users/{userId}/tokens/{pushId}")
    .onCreate(async (snapshot, context) => {
        const userId = context.params.userId;
        const newToken = snapshot.val();
        const tokensRef = snapshot.ref.parent;

        // Query all tokens matching the new token value
        const duplicateQuery = tokensRef.orderByValue().equalTo(newToken);
        const duplicatesSnapshot = await duplicateQuery.once("value");

        // Keep the first occurrence, delete all others
        let keepFirst = true;
        duplicatesSnapshot.forEach((childSnapshot) => {
            if (!keepFirst) {
                childSnapshot.ref.remove();
            }
            keepFirst = false;
        });
    });

Note: This function runs after the duplicate is created, so there might be a brief window where duplicates exist. For most use cases, the client-side approach is preferable to avoid this.

Final Recommendation #

Prioritize the client-side approach using device IDs as keys—it’s more efficient, avoids unnecessary cloud function costs, and ensures you only store active, non-duplicate tokens. Use Firebase Functions for deduplication only if client-side changes aren’t feasible.

内容的提问来源于stack exchange，提问作者Ruslan Leshchenko