Topic Subscription i push-notiser — vad det är, hur det fungerar och konfigureras

Vad är Topic Subscription i FCM

Topic Subscription — är en mekanism för gruppvis push-notiser där enheter prenumererar på namngivna kanaler (ämnen) och tar emot meddelanden som skickas till dessa kanaler. Varje ämne identifieras av ett strängnamn, till exempel news_sports eller weather_alerts.

Funktionsprincip för ämnen

När en enhet prenumererar på ett ämne lägger FCM till dess Registration Token i listan över mottagare för det ämnet. När ett meddelande skickas till ett ämne dirigerar FCM automatiskt en kopia till varje prenumererad enhet. Firebase begränsar inte antalet prenumerationer per enhet — applikationen kan prenumerera användaren på dussintals ämnen samtidigt.

Ämnen jämfört med individuell sändning

Den största fördelen med ämnen är skalbarhet. För att skicka en notis till en miljon användare räcker det med en HTTP-förfrågan till FCM med ämnets namn. Vid individuell sändning skulle en miljon förfrågningar eller batch-sändning av upp till 500 tokens åt gången krävas. Ämnen förenklar också serverlogiken — det finns inget behov av att lagra tokenlistor för varje kategori.

Exempel på användning av ämnen

Topic Subscription används flitigt i nyhetsappar för kategorisering av innehåll — prenumeration på ämnena "Sport", "Politik", "Teknik" gör det möjligt att leverera relevanta notiser. Inom e-handel används ämnen för notiser om rabatter i specifika produktkategorier. I meddelandetjänster och sociala nätverk används ämnen för notiser om händelser i grupper.

FCM-begränsningar och gränser

Firebase sätter begränsningar för arbete med ämnen. En applikation kan ha upp till 2000 ämnen. Varje enhet kan prenumerera på högst 2000 ämnen. Frekvensen av prenumerationer/avprenumerationer är också begränsad — inte mer än 3000 operationer per minut per projekt. Överskridande av gränser leder till temporär blockering. För projekt med ett stort antal ämnen rekommenderas att använda en condition istället för ämne — FCM stöder logiska uttryck för målgruppsanpassning.

Hur ämnesprenumeration fungerar

Processen Topic Subscription består av tre steg: initiering av prenumerationen på klienten, registrering i FCM-infrastrukturen och bekräftelse av operationen. Efter en lyckad prenumeration börjar enheten ta emot meddelanden som skickats till det ämnet.

Prenumerationens livscykel

När klienten anropar metoden subscribeToTopic() skickar Firebase SDK en förfrågan till FCM-servrarna. Servern kontrollerar operationens tillåtlighet och lägger till enhetens token i listan över prenumeranter för ämnet. FCM returnerar bekräftelse på lyckad prenumeration till klienten. Från och med detta ögonblick kommer alla meddelanden på detta ämne att levereras till enheten.

Automatisk skapande av ämne

Ämnet behöver inte skapas i förväg i Firebase-konsolen. Vid den första prenumerationen av någon enhet på ett ämne som heter news_promo skapar FCM det automatiskt. Om den sista enheten avprenumererar förblir ämnet i systemet men inaktivt och återupptar arbetet vid en ny prenumeration.

Ämnesprenumeration på Android

På Android utförs prenumeration och avprenumeration på ämnen via FirebaseMessaging SDK. Metoderna subscribeToTopic() och unsubscribeFromTopic() tar ämnets namn som parameter. Operationerna är asynkrona och kräver hantering av resultatet.

Grundläggande ämnesprenumeration

För att prenumerera räcker det att anropa subscribeToTopic() med namnet på det önskade ämnet. Firebase SDK hanterar självständigt nätverksförfrågningar och återförsök vid fel. Det rekommenderas att prenumerera på ämnen efter att ha tagit emot Registration Token.

class TopicSubscriber(private val context: Context) {

    fun subscribeToNewsTopic() {
        FirebaseMessaging.getInstance()
            .subscribeToTopic("news_latest")
            .addOnCompleteListener { task ->
                val msg = if (task.isSuccessful) {
                    "Subscribed to news topic"
                } else {
                    "Subscription failed"
                }
                Log.d("FCM", msg)
            }
    }

    fun unsubscribeFromNewsTopic() {
        FirebaseMessaging.getInstance()
            .unsubscribeFromTopic("news_latest")
            .addOnCompleteListener { task ->
                Log.d("FCM", "Avprenumererad: ${task.isSuccessful}")
            }
    }
}

Hantera flera prenumerationer

I verkliga applikationer kan användaren prenumerera på flera kategorier. För bekväm hantering, skapa en hanterarklass som synkroniserar prenumerationsstatus med serverdelen. När användaren loggar in, återställ deras prenumerationer från profilen.

class SubscriptionManager(private val context: Context) {

    private val fcm = FirebaseMessaging.getInstance()

    suspend fun syncSubscriptions(topics: List<String>) {
        topics.forEach { topic ->
            fcm.subscribeToTopic(topic).await()
        }
    }

    suspend fun removeAllSubscriptions() {
        val savedTopics = getSavedTopics()
        savedTopics.forEach { topic ->
            fcm.unsubscribeFromTopic(topic).await()
        }
    }

    private fun getSavedTopics(): List<String> {
        return listOf("news_latest", "promotions", "updates")
    }
}

Ämnesprenumeration på iOS

På iOS är processen för att prenumerera på ämnen logiskt identisk med Android men använder Firebase Messaging Swift API. Metoderna subscribe och unsubscribe anropas på Messaging-instansen och är också asynkrona.

Implementering av prenumeration på iOS

För att prenumerera på ett ämne i en iOS-app används metoden Messaging.subscribe(). Det är viktigt att anropa prenumerationen efter initiering av Firebase och mottagande av Registration Token. Apple rekommenderar att begära tillstånd för notiser före prenumeration på ämnen.

import FirebaseMessaging

class PushTopicManager {

    func subscribeToTopic(topic: String) {
        Messaging.messaging().subscribe(toTopic: topic) { error in
            if let error = error {
                Log.e("FCM", "Prenumerationsfel: \(error)")
            } else {
                Log.d("FCM", "Prenumererad på \(topic)")
            }
        }
    }

    func unsubscribeFromTopic(topic: String) {
        Messaging.messaging().unsubscribe(fromTopic: topic) { error in
            if let error = error {
                Log.e("FCM", "Avprenumerationsfel: \(error)")
            }
        }
    }
}

Egenskaper för iOS-prenumerationer

På iOS är prenumerationen på ett ämne också kopplad till Registration Token som Firebase får från APNs. Om APNs-token ändras (till exempel efter återställning av enheten) överför Firebase automatiskt prenumerationerna till den nya token. I sällsynta fall kan dock ompremuneration krävas efter uppdatering av Registration Token.

Hantera prenumerationer från servern

Serverhantering av prenumerationer gör det möjligt att prenumerera och avprenumerera enheter utan klientapplikationens medverkan. Detta är användbart för administration, A/B-testning och hantering av prenumerationer på backend-sidan.

FCM HTTP API för prenumerationshantering

Firebase tillhandahåller ett REST API för masshantering av prenumerationer. Metoden /v1/projects/{project_id}/subscriptions gör det möjligt att prenumerera upp till 1000 enheter i en enda förfrågan. API:et använder enheternas Registration Token för identifiering.

const admin = require("firebase-admin")

async function subscribeUsersToTopic(tokens, topic) {
    try {
        const response = await admin
            .messaging()
            .subscribeToTopic(tokens, topic)
        Log.info(`Success: ${response.successCount}`)
        Log.info(`Failures: ${response.failureCount}`)
    } catch (error) {
        Log.error("Prenumerationsfel", error)
    }
}

Användningsscenarier för serverhantering

Serverhantering av prenumerationer används i flera scenarier. Vid användarregistrering prenumererar servern automatiskt på grundläggande ämnen. Vid ändring av preferenser i webbversionen synkroniserar servern prenumerationerna på den mobila enheten. Administratörer kan prenumerera testenheter på interna ämnen för felsökning. För massoperationer tillhandahåller FCM metoden Instance Group, som gör det möjligt att hantera prenumerationer för en grupp enheter via en enda gruppidentifierare.

Övervakning av prenumerationsstatus

Firebase tillhandahåller inget inbyggt API för att kontrollera enhetens aktuella prenumerationer. Utvecklare rekommenderas att hålla en egen prenumerationsdatabas på serversidan. Vid varje appstart synkroniserar klienten sina prenumerationer med servern genom att skicka en lista över aktiva ämnen. Detta gör det möjligt att upptäcka avsynkronisering och återställa prenumerationer vid behov. För granskning, använd Firebase Cloud Functions-loggar — varje subscribe/unsubscribe-operation kan loggas.