Gestion des jetons d’actualisation pour les groupes de périphériques FCM

J’essaie d’implémenter la messagerie en nuage Firebase dans mon application Android via un serveur Node.js et je me suis retrouvé coincé dans un cas d’utilisation.

J’ai vu le tutoriel Firebase sur la création d’un groupe de périphériques utilisant des jetons d’enregistrement pour envoyer des messages / notifications à tous les périphériques avec le même utilisateur connecté. Ce que je ne comprends pas, c’est ce qui se produit lorsqu’un des jetons d’enregistrement est actualisé par la méthode onTokenRefresh () .

Comment vais-je distinguer quel jeton changer, étant donné que tous appartiendront au même utilisateur?

Mettre à jour:

Ok, alors maintenant je suis coincé sur un autre cas d’utilisation bloquante. Je crée un groupe d’utilisateurs identifié par l’ID utilisateur de mon serveur. Si l’utilisateur désinstalle et réinstalle immédiatement l’application et qu’un autre utilisateur se connecte au périphérique, si j’appelle un message gcm sur le groupe d’utilisateurs précédent, ce périphérique le reçoit tout de même.

Existe-t-il un moyen permettant à gcm de déterminer si le périphérique auquel il envoie la notification est connecté ou non et, le cas échéant, est-il connecté avec le même utilisateur que pour le groupe?

J’ai donc réfléchi à la manière de procéder avec ce scénario. Tout d’abord, mettons dans les instances où onRefreshToken () est appelé:

Cela ne sera pas appelé très fréquemment , il est nécessaire pour la rotation de la clé et pour gérer les changements d’ID d’instance pour les raisons suivantes:

  • L’application supprime l’ID d’instance
  • L’application est restaurée sur un nouvel appareil
  • L’utilisateur désinstalle / réinstalle l’application
  • L’utilisateur efface les données de l’application

Devinez avec ça, vous pouvez dire que ‘onTokenRefresh () `sera appelé après qu’un des événements ci-dessus se produise et que le périphérique soit en ligne ( il doit bien sûr être en ligne pour obtenir un nouveau jeton ). Donc je suppose que voici comment je vais aller sur le scénario:

Tout d’abord, lors de l’enregistrement, je voudrais enregistrer le jeton d’enregistrement et le coupler avec un autre identifiant, disons un deviceId ( puisque nous sums dans un scénario pour un utilisateur possédant plusieurs appareils ) dans mon serveur d’applications.

Supposons donc que j’ajoute 3 jetons d’enregistrement, qui sont également associés à leurs deviceIds. Je les ajoute tous à un groupe de périphériques.

Maintenant, disons que l’un des périphériques déclenche la fonction onTokenRefresh() , j’enverrais immédiatement une demande de suppression à mon serveur d’application pour le jeton d’enregistrement actuellement associé à ce deviceId (vous devez également le supprimer dans tous les groupes de périphériques auxquels il est connecté). ), en le remplaçant par le nouveau, puis rajoutez-le au (x) groupe (s) d’appareils correspondant (s).

C’est le moyen le plus simple auquel je puisse penser. Ici, la clé est de lier les jetons d’enregistrement à un autre identifiant et de les utiliser pour trouver le jeton d’enregistrement à remplacer.

Il existe un autre moyen de résoudre ce problème en utilisant Cloud Firebase Functions.

Comment vais-je distinguer quel jeton changer, étant donné que tous appartiendront au même utilisateur?

En utilisant les fonctions Firebase, vous n’êtes pas obligé. Dans onTokenRefresh (), vous envoyez le nouveau jeton au serveur.

Par exemple:

L’utilisateur dispose de 3 périphériques, chacun d’eux ayant un jeton qui a été envoyé au serveur.

*** deviceTokenA / B / C représente les UID du jeton … Nous ne soaps pas ce qu’ils sont ou à quel périphérique ils appartiennent.

 UserId: Device Tokens: deviceTokenA: true, deviceTokenB: true, deviceTokenC: true, 

Maintenant, l’utilisateur est sur le périphérique qui a déclenché deviceTokenA. Le jeton est actualisé et onTokenRefresh () est appelé pour l’envoyer à cette collection.

 onTokenRefresh() { Ssortingng refreshedToken = FirebaseInstanceId.getInstance().getToken(); sendTokenToServer(refreshedToken); } sendTokenToServer(Ssortingng refreshedToken) { // send to Firebase or Firestore Database, put in the Device_Tokens collection. } 

Maintenant, vous aurez 4 jetons dans la collection.

  UserId: Device Tokens: deviceTokenA: true, // this one has been "unregistered" deviceTokenB: true, deviceTokenC: true, deviceTokenD: true, // this one has been registered. 

DeviceTokenA ne s’applique plus car il a été actualisé et n’est plus connecté à un périphérique réel.

En regardant les jetons de périphérique, nous ne soaps toujours pas lesquels sont bons, lesquels sont mauvais et quels jetons appartiennent à quel périphérique. C’est bon!

Alors, créez ensuite une boucle forEach, récupérant chaque jeton, puis envoyez un FCM à chacun de ces jetons, FCM peut nous indiquer quels jetons ont été envoyés avec succès. L’un d’eux retournera une erreur. S’il renvoie une erreur indiquant que le jeton était incorrect, nous pouvons alors détecter l’erreur et supprimer ce jeton afin qu’il ne soit pas appelé à nouveau.

 // outside for Each loop var promiseHolder = []; // create a forEach loop, iterating through the collection of deviceTokens // within that loop, put: let innerPromise = admin.messaging().send(message) .then(response => { console.log('notification sent success: ' + response); }) .catch((error) => { console.log('Error sending notification: ' + error); // if the error == bad token message, then Delete the Token. if (error == 'Error: Requested entity was not found.') { console.log('you matched the error, token doesn't work, handle here.'); //delete the old token return admin.firestore()doc(`users/${userID}/device_tokens/${token_id}`).delete(); } } // still within forEach loop promiseHolder.push(innerPromise); // end the forEach Loop, and outside forEachLoop put: return Promise.all(promiseHolder); 

au moment j’utilise cette méthode. dans ma firebase database, je crée un nœud avec l’identifiant de l’appareil

 deviceId: { uid1: deviceId, uid2: deviceId, uid3: deviceId } 

un autre noeud avec les utilisateurs abonnés pour recevoir une notification

 newsSubscriber: { uid1: [array of subscribers], uid2: [array of subscribers], uid3: [array of subscribers] } 

quand je peux envoyer une notification par mon script nodejs, je reçois tous les utilisateurs enregistrés dans le nœud newsSubscriber, et pour tout utilisateur, je récupère son deviceId et je le mets dans un tableau de périphériques pour envoyer une notification. Il n’y a qu’un seul problème, je lis maintenant que dans ce mode, il n’y a qu’une limite de 20 appareils !

mais je pense que c’est une bonne méthode facile d’avoir un deviceId correspondant pour tout utilisateur, car lorsque j’utilise la déconnexion ou la connexion dans mon application, je peux changer le deviceId correspondant pour tout utilisateur, afin d’avoir une cohérence entre l’utilisateur et l’appareil.

que se passe-t-il si, pour contourner la limite de 20 appareils, j’envoie la même notification à différents groupes de 20 appareils?