Firebase functions cloud messaging notification not being recieved

Issue

When I send a notification from the Firebase cloud messaging console, my device receives it without a problem, but when I send it via a cloud functions, the function log says it was successfully sent but my device does not receive it. I tried switching to type script, sending the notification with different conditions but nothing works. The app is written in flutter.

My function code:

exports.sendNotification  functions.https.onRequest((request, response) > {
    const db  admin.firestore();
    const fcm  admin.messaging();
    db.collection("users")
        .where("bananas", "", 1666).get().then(
            (result) > {
                if (result.size > 0) {
                    result.forEach((doc) > {
                          const payload  {
                            token: doc.data().NotToken,
                            notification: {
                              title: "iam a notification",
                              body: "Yay",
                              icon: "https://cdn1.iconfinder.com/data/icons/logos-brands-in-colors/231/among-us-player-white-512.png",
                            },
                          };
                          fcm.send(payload).then((response) > {
                            // Response is a message ID string.
                            console.log("Successfully sent message: "+
                            doc.data().NotToken+ "  ", response);
                            return {success: true};
                        }).catch((error) > {
                            return {error: error.code};
                        });
                    });
                }
            });
    response.send("Notification sent !");
    functions.logger.info("Notification sent!");
    return null; 
});

cloud log

Any ideas?

Solution

Did you notice how your code never logs this message?

Successfully sent message

That’s because both loading from Firestore, and sending messaging through Cloud Messaging are asynchronous calls. So your response.send("Notification sent !") runs before the data is ever retrieved from the database, and Cloud Functions at that point terminates your code to prevent charging after you say that you are done.

If you have asynchronous operations in your code, you need to return a promise from the top-level of your code that resolves/rejects when all asynchronous code has completed. So in your case that means the promise should only resolve once you’ve loaded the data from Firestore, and sent the messages.


Let’s start with a simple example. Say that you want to only send a single message, no matter how many documents are in the database.

exports.sendNotification  functions.https.onRequest((request, response) > {
    const db  admin.firestore();
    const fcm  admin.messaging();
    return db.collection("users") // 👈 Add return here
        .where("bananas", "", 1666).get().then((result) > {
            if (result.size > 0) {
                const doc  result.docs[0]; // 👈 Get the first result
                  const payload  {
                    token: doc.data().NotToken,
                    notification: {
                      title: "iam a notification",
                      body: "Yay",
                      icon: "https://cdn1.iconfinder.com/data/icons/logos-brands-in-colors/231/among-us-player-white-512.png",
                    },
                  };
                  return fcm.send(payload).then((response) > { // 👈 Add return here
                    console.log("Successfully sent message: "+
                    doc.data().NotToken+ "  ", response);
                    response.send("Notification sent !"); // 👈 Move this call here
                    return {success: true};
                }).catch((error) > {
                    // TODO: Send an error back to the caller
                    return {error: error.code};
                });
            }
        });
});

So the top-level code now returns the result from loading data from Firestore, and in there, we return the call from calling FCM, which then in turn returns return {success: true};. When returning promises, the results bubble up – so you can typically just keep returning the nested results.

You’ll also not that we’ve moved the response.send into the code that runs after calling FCM, as we don’t want to send a result back to the caller until the FCM call is done.


The above is the simple variant, because in reality you have multiple documents, and you are only done once all of them are done.

For that we are going to use Promise.all(), which takes an array of promises and resolves once all those promises resolve. So we’re going to capture all the calls to FCM (which returns a promise) and collection them in an array, that we then pass to Promise.all().

exports.sendNotification  functions.https.onRequest((request, response) > {
    const db  admin.firestore();
    const fcm  admin.messaging();
    return db.collection("users")
      .where("bananas", "", 1666).get().then((result) > {
        if (result.size > 0) {
            let promises  [];
            result.forEach((doc) > {
                const payload  {
                  token: doc.data().NotToken,
                  notification: {
                    title: "iam a notification",
                    body: "Yay",
                    icon: "https://cdn1.iconfinder.com/data/icons/logos-brands-in-colors/231/among-us-player-white-512.png",
                  },
                };
                promises.push(fcm.send(payload))
            });
            return Promise.al(promises).then((results) > {
                console.log("Successfully sent messages");
                response.send("Notification sent !");
                return {success: true};
            });
        }
    });
});

While this may be a lot to grok all at once, handling asynchronous behavior is quite well covered in the Firebase documentation on terminating functions, in this video series on Learn JavaScript Promises with Cloud Functions, and in quite a few tutorials out there – so I recommend spending some time on those to get to grips with asynchronous code.

Answered By – Frank van Puffelen

Leave a Comment