Les SDK client Cloud Functions for Firebase vous permettent d'appeler des fonctions directement à partir d'une application Firebase. Pour appeler une fonction de cette manière à partir de votre application, écrivez et déployez une fonction HTTP appelable dans Cloud Functions, puis ajoutez une logique client pour appeler la fonction à partir de votre application.
Il est important de garder à l'esprit que les fonctions HTTP appelables sont similaires aux fonctions HTTP, mais pas identiques. Pour utiliser des fonctions HTTP appelables, vous devez utiliser le SDK client pour votre plate-forme avec l'API de backend (ou implémenter le protocole). Les fonctions appelables présentent les différences clés suivantes par rapport aux fonctions HTTP :
- Avec les éléments appelables, les jetons Firebase Authentication, FCM et App Check, lorsqu'ils sont disponibles, sont automatiquement inclus dans les requêtes.
- Le déclencheur désérialise automatiquement le corps de la requête et valide les jetons d'authentification.
Le SDK Firebase pour Cloud Functions de 2e génération et versions ultérieures interagit avec les versions minimales suivantes des SDK client Firebase pour prendre en charge les fonctions appelables HTTPS :
- Firebase SDK pour les plates-formes Apple 12.0.0
- SDK Firebase pour Android 21.2.1
- SDK Web modulaire Firebase v. 9.7.0
Si vous souhaitez ajouter des fonctionnalités similaires à une application créée sur une plate-forme non compatible, consultez les spécifications du protocole pour https.onCall. Le reste de ce guide fournit des instructions sur la façon d'écrire, de déployer et d'appeler une fonction HTTP appelable pour les plates-formes Apple, Android, Web, C++ et Unity.
Écrire et déployer la fonction appelable
Les exemples de code de cette section sont basés sur un exemple de démarrage rapide complet qui montre comment envoyer des requêtes à une fonction côté serveur et obtenir une réponse à l'aide de l'un des SDK client. Pour commencer, importez les modules requis :
Node.js
// Dependencies for callable functions.
const {onCall, HttpsError} = require("firebase-functions/v2/https");
const {logger} = require("firebase-functions/v2");
// Dependencies for the addMessage function.
const {getDatabase} = require("firebase-admin/database");
const sanitizer = require("./sanitizer");
Python
# Dependencies for callable functions.
from firebase_functions import https_fn, options
# Dependencies for writing to Realtime Database.
from firebase_admin import db, initialize_app
Utilisez le gestionnaire de requêtes pour votre plate-forme (functions.https.onCall ou on_call) pour créer une fonction appelable HTTPS. Cette méthode utilise un paramètre de requête :
Node.js
// Saves a message to the Firebase Realtime Database but sanitizes the
// text by removing swearwords.
exports.addmessage = onCall((request) => {
// ...
});
Python
@https_fn.on_call()
def addmessage(req: https_fn.CallableRequest) -> Any:
"""Saves a message to the Firebase Realtime Database but sanitizes the text
by removing swear words."""
Le paramètre request contient les données transmises par l'application cliente, ainsi que des informations contextuelles supplémentaires, comme l'état de l'authentification. Pour une fonction appelable qui enregistre un message texte dans Realtime Database, par exemple, data peut contenir le texte du message, ainsi que des informations d'authentification dans auth :
Node.js
// Message text passed from the client.
const text = request.data.text;
// Authentication / user information is automatically added to the request.
const uid = request.auth.uid;
const name = request.auth.token.name || null;
const picture = request.auth.token.picture || null;
const email = request.auth.token.email || null;
Python
# Message text passed from the client.
text = req.data["text"]
# Authentication / user information is automatically added to the request.
uid = req.auth.uid
name = req.auth.token.get("name", "")
picture = req.auth.token.get("picture", "")
email = req.auth.token.get("email", "")
La distance entre l'emplacement de la fonction appelable et celui du client appelant peut créer une latence réseau. Pour optimiser les performances, envisagez de spécifier l'emplacement de la fonction, le cas échéant, et assurez-vous d'aligner l'emplacement de l'appelable sur l'emplacement défini lorsque vous initialisez le SDK côté client.
Vous pouvez éventuellement joindre une attestation App Check pour protéger vos ressources de backend contre les utilisations abusives, comme la fraude à la facturation ou l'hameçonnage. Consultez Activer l'application App Check pour Cloud Functions.
Renvoyer le résultat
Pour renvoyer des données au client, renvoyez des données pouvant être encodées au format JSON. Par exemple, pour renvoyer le résultat d'une opération d'addition :
Node.js
// returning result.
return {
firstNumber: firstNumber,
secondNumber: secondNumber,
operator: "+",
operationResult: firstNumber + secondNumber,
};
Python
return {
"firstNumber": first_number,
"secondNumber": second_number,
"operator": "+",
"operationResult": first_number + second_number
}
Le texte nettoyé de l'exemple de texte du message est renvoyé au client et à Realtime Database. Dans Node.js, cela peut être fait de manière asynchrone à l'aide d'une promesse JavaScript :
Node.js
// Saving the new message to the Realtime Database.
const sanitizedMessage = sanitizer.sanitizeText(text); // Sanitize message.
return getDatabase().ref("/messages").push({
text: sanitizedMessage,
author: {uid, name, picture, email},
}).then(() => {
logger.info("New Message written");
// Returning the sanitized message to the client.
return {text: sanitizedMessage};
})
Python
# Saving the new message to the Realtime Database.
sanitized_message = sanitize_text(text) # Sanitize message.
db.reference("/messages").push({ # type: ignore
"text": sanitized_message,
"author": {
"uid": uid,
"name": name,
"picture": picture,
"email": email
}
})
print("New message written")
# Returning the sanitized message to the client.
return {"text": sanitized_message}
Envoyer et recevoir des résultats de streaming
Les fonctions appelables disposent de mécanismes pour gérer les résultats de streaming. Si vous avez un cas d'utilisation qui nécessite le streaming, vous pouvez configurer le streaming dans la requête appelable, puis utiliser la méthode appropriée du SDK client pour appeler la fonction.
Envoyer les résultats de streaming
Pour diffuser efficacement les résultats générés au fil du temps, par exemple à partir de plusieurs requêtes API distinctes ou d'une API d'IA générative, vérifiez la propriété acceptsStreaming sur votre requête appelable. Lorsque cette propriété est définie sur true, vous pouvez renvoyer les résultats au client avec response.sendChunk().
Par exemple, si une application a besoin de récupérer des données de prévisions météo pour plusieurs lieux, la fonction appelable peut envoyer les prévisions de chaque lieu séparément aux clients qui ont demandé une réponse en streaming, au lieu de les faire attendre jusqu'à ce que toutes les demandes de prévisions soient résolues :
exports.getForecast = onCall(async (request, response) => { if (request.data?.locations?.length < 1) { throw new HttpsError("invalid-argument", "Missing locations to forecast"); } // fetch forecast data for all requested locations const allRequests = request.data.locations.map( async ({latitude, longitude}) => { const forecast = await weatherForecastApi(latitude, longitude); const result = {latitude, longitude, forecast}; // clients that support streaming will have each // forecast streamed to them as they complete if (request.acceptsStreaming) { response.sendChunk(result); } return result; }, ); // Return the full set of data to all clients return Promise.all(allRequests); });
Notez que le fonctionnement de response.sendChunk() dépend de certains détails de la demande du client :
Si le client demande une réponse en flux continu,
response.sendChunk(data)envoie immédiatement le fragment de données.Si le client ne demande pas de réponse en streaming,
response.sendChunk()ne fait rien pour cet appel. La réponse complète est envoyée une fois que toutes les données sont prêtes.
Pour déterminer si le client demande une réponse en streaming, vérifiez la propriété request.acceptsStreaming. Par exemple, si request.acceptsStreaming est défini sur "false", vous pouvez décider d'ignorer tout travail gourmand en ressources spécifiquement lié à la préparation ou à l'envoi de blocs individuels, car le client ne s'attend pas à une diffusion incrémentielle.
Recevoir des résultats de streaming
Dans un scénario typique, le client demande le streaming avec la méthode .stream, puis parcourt les résultats :
Swift
func listenToWeatherForecast() async throws {
isLoading = true
defer { isLoading = false }
Functions
.functions(region: "us-central1")
let getForecast: Callable<WeatherRequest, StreamResponse<WeatherResponse, [WeatherResponse]>> = Functions.functions().httpsCallable("getForecast")
let request = WeatherRequest(locations: locations)
let stream = try getForecast.stream(request)
for try await response in stream {
switch response {
case .message(let singleResponse):
weatherData["\(singleResponse.latitude),\(singleResponse.longitude)"] = singleResponse
case .result(let arrayOfResponses):
for response in arrayOfResponses {
weatherData["\(response.latitude),\(response.longitude)"] = response
}
print("Stream ended.")
return
}
}
}
Web
// Get the callable by passing an initialized functions SDK.
const getForecast = httpsCallable(functions, "getForecast");
// Call the function with the `.stream()` method to start streaming.
const { stream, data } = await getForecast.stream({
locations: favoriteLocations,
});
// The `stream` async iterable returned by `.stream()`
// will yield a new value every time the callable
// function calls `sendChunk()`.
for await (const forecastDataChunk of stream) {
// update the UI every time a new chunk is received
// from the callable function
updateUi(forecastDataChunk);
}
// The `data` promise resolves when the callable
// function completes.
const allWeatherForecasts = await data;
finalizeUi(allWeatherForecasts);
Parcourez l'itérable asynchrone stream comme indiqué. L'attente de la promesse data indique au client que la requête est terminée.
Kotlin
// Get the callable by passing an initialized functions SDK.
val getForecast = functions.getHttpsCallable("getForecast");
// Call the function with the `.stream()` method and convert it to a flow
getForecast.stream(
mapOf("locations" to favoriteLocations)
).asFlow().collect { response ->
when (response) {
is StreamResponse.Message -> {
// The flow will emit a [StreamResponse.Message] value every time the
// callable function calls `sendChunk()`.
val forecastDataChunk = response.message.data as Map<String, Any>
// Update the UI every time a new chunk is received
// from the callable function
updateUI(
forecastDataChunk["latitude"] as Double,
forecastDataChunk["longitude"] as Double,
forecastDataChunk["forecast"] as Double,
)
}
is StreamResponse.Result -> {
// The flow will emit a [StreamResponse.Result] value when the
// callable function completes.
val allWeatherForecasts = response.result.data as List<Map<String, Any>>
finalizeUI(allWeatherForecasts)
}
}
}
Pour utiliser la fonction d'extension asFlow(), ajoutez la bibliothèque org.jetbrains.kotlinx:kotlinx-coroutines-reactive en tant que dépendance au fichier build.gradle(.kts) de l'application.
Java
// Get the callable by passing an initialized functions SDK.
HttpsCallableReference getForecast = mFunctions.getHttpsCallable("getForecast");
getForecast.stream(
new HashMap<String, Object>() {{
put("locations", favoriteLocations);
}}
).subscribe(new Subscriber<StreamResponse>() {
@Override
public void onSubscribe(Subscription subscription) {
subscription.request(Long.MAX_VALUE);
}
@Override
public void onNext(StreamResponse streamResponse) {
if (streamResponse instanceof StreamResponse.Message) {
// The flow will emit a [StreamResponse.Message] value every time the
// callable function calls `sendChunk()`.
StreamResponse.Message response = (StreamResponse.Message) streamResponse;
Map<String, Object> forecastDataChunk =
(Map<String, Object>) response.getMessage().getData();
// Update the UI every time a new chunk is received
// from the callable function
updateUI(
(double) forecastDataChunk.get("latitude"),
(double) forecastDataChunk.get("longitude"),
(double) forecastDataChunk.get("forecast")
);
} else if(streamResponse instanceof StreamResponse.Result) {
// The flow will emit a [StreamResponse.Result] value when the
// callable function completes.
StreamResponse.Result response = (StreamResponse.Result) streamResponse;
List<Map<String, Object>> allWeatherForecasts =
(List<Map<String, Object>>) response.getResult().getData();
finalizeUI();
}
}
@Override
public void onError(Throwable throwable) {
// an error occurred in the function
}
@Override
public void onComplete() {
}
});
Configurer CORS (partage des ressources entre origines multiples)
Utilisez l'option cors pour contrôler les origines pouvant accéder à votre fonction.
Par défaut, les fonctions appelables sont configurées avec CORS pour autoriser les requêtes provenant de toutes les origines. Pour autoriser certaines requêtes d'origine croisée, mais pas toutes, transmettez une liste de domaines spécifiques ou d'expressions régulières qui doivent être autorisés. Exemple :
Node.js
const { onCall } = require("firebase-functions/v2/https");
exports.getGreeting = onCall(
{ cors: [/firebase\.com$/, "https://flutter.com"] },
(request) => {
return "Hello, world!";
}
);
Pour interdire les requêtes cross-origin, définissez la règle cors sur false.
Gérer les erreurs
Pour que le client obtienne des informations utiles sur les erreurs, renvoyez les erreurs d'une fonction appelable en générant (ou, pour Node.js, en renvoyant une promesse rejetée avec) une instance de functions.https.HttpsError ou https_fn.HttpsError.
L'erreur comporte un attribut code qui peut prendre l'une des valeurs listées dans les codes d'état gRPC.
Les erreurs comportent également une chaîne message, qui est vide par défaut. Ils peuvent également comporter un champ details facultatif avec une valeur arbitraire. Si une erreur autre qu'une erreur HTTPS est générée par vos fonctions, votre client reçoit à la place une erreur avec le message INTERNAL et le code internal.
Par exemple, une fonction peut générer des erreurs de validation des données et d'authentification avec des messages d'erreur à renvoyer au client appelant :
Node.js
// Checking attribute.
if (!(typeof text === "string") || text.length === 0) {
// Throwing an HttpsError so that the client gets the error details.
throw new HttpsError("invalid-argument", "The function must be called " +
"with one arguments \"text\" containing the message text to add.");
}
// Checking that the user is authenticated.
if (!request.auth) {
// Throwing an HttpsError so that the client gets the error details.
throw new HttpsError("failed-precondition", "The function must be " +
"called while authenticated.");
}
Python
# Checking attribute.
if not isinstance(text, str) or len(text) < 1:
# Throwing an HttpsError so that the client gets the error details.
raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.INVALID_ARGUMENT,
message=('The function must be called with one argument, "text",'
" containing the message text to add."))
# Checking that the user is authenticated.
if req.auth is None:
# Throwing an HttpsError so that the client gets the error details.
raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.FAILED_PRECONDITION,
message="The function must be called while authenticated.")
Déployer la fonction appelable
Une fois que vous avez enregistré une fonction appelable terminée dans index.js, elle est déployée avec toutes les autres fonctions lorsque vous exécutez firebase deploy.
Pour déployer uniquement l'appelable, utilisez l'argument --only comme indiqué pour effectuer des déploiements partiels :
firebase deploy --only functions:addMessage
Si vous rencontrez des erreurs d'autorisation lors du déploiement de fonctions, assurez-vous que les rôles IAM appropriés sont attribués à l'utilisateur qui exécute les commandes de déploiement.
Configurer votre environnement de développement client
Assurez-vous de remplir toutes les conditions préalables, puis ajoutez les dépendances et les bibliothèques clientes requises à votre application.
iOS+
Suivez les instructions pour ajouter Firebase à votre application Apple.
Utilisez Swift Package Manager pour installer et gérer les dépendances Firebase.
- Dans Xcode, à partir de votre projet d'application ouvert, accédez à File > Add Packages (Fichier > Ajouter des packages).
- Lorsque vous y êtes invité, ajoutez le dépôt du SDK des plates-formes Firebase pour Apple :
- Choisissez la bibliothèque Cloud Functions.
- Ajoutez l'indicateur
-ObjCà la section Other Linker Flags (Autres indicateurs Linker) des paramètres de compilation de votre cible. - Lorsque vous avez terminé, Xcode commence à résoudre et à télécharger automatiquement vos dépendances en arrière-plan.
https://github.com/firebase/firebase-ios-sdk.git
Web
- Suivez les instructions pour ajouter Firebase à votre application Web. Veillez à exécuter la commande suivante depuis votre terminal :
npm install firebase@11.10.0 --save
Chargez manuellement le cœur de Firebase et Cloud Functions :
import { initializeApp } from 'firebase/app'; import { getFunctions } from 'firebase/functions'; const app = initializeApp({ projectId: '### CLOUD FUNCTIONS PROJECT ID ###', apiKey: '### FIREBASE API KEY ###', authDomain: '### FIREBASE AUTH DOMAIN ###', }); const functions = getFunctions(app);
Android
Suivez les instructions pour ajouter Firebase à votre application Android.
Dans le fichier Gradle de votre module (au niveau de l'application) (généralement
<project>/<app-module>/build.gradle.ktsou<project>/<app-module>/build.gradle), ajoutez la dépendance pour la bibliothèque Cloud Functions pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler le versionnage de la bibliothèque.dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:33.16.0")) // Add the dependency for the Cloud Functions library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions") }
En utilisant la Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Alternative) Ajoutez les dépendances de la bibliothèque Firebase sans utiliser BoM.
Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier la version de chaque bibliothèque Firebase sur sa ligne de dépendance.
Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons vivement d'utiliser BoM pour gérer les versions des bibliothèques, ce qui garantit que toutes les versions sont compatibles.
dependencies { // Add the dependency for the Cloud Functions library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-functions:21.2.1") }
Initialiser le SDK client
Initialisez une instance de Cloud Functions :
Swift
lazy var functions = Functions.functions()
Objective-C
@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];
Web
const app = initializeApp({
projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
apiKey: '### FIREBASE API KEY ###',
authDomain: '### FIREBASE AUTH DOMAIN ###',
});
const functions = getFunctions(app);
Kotlin
private lateinit var functions: FirebaseFunctions // ... functions = Firebase.functions
Java
private FirebaseFunctions mFunctions; // ... mFunctions = FirebaseFunctions.getInstance();
Appeler la fonction
Swift
functions.httpsCallable("addMessage").call(["text": inputField.text]) { result, error in
if let error = error as NSError? {
if error.domain == FunctionsErrorDomain {
let code = FunctionsErrorCode(rawValue: error.code)
let message = error.localizedDescription
let details = error.userInfo[FunctionsErrorDetailsKey]
}
// ...
}
if let data = result?.data as? [String: Any], let text = data["text"] as? String {
self.resultField.text = text
}
}
Objective-C
[[_functions HTTPSCallableWithName:@"addMessage"] callWithObject:@{@"text": _inputField.text}
completion:^(FIRHTTPSCallableResult * _Nullable result, NSError * _Nullable error) {
if (error) {
if ([error.domain isEqual:@"com.firebase.functions"]) {
FIRFunctionsErrorCode code = error.code;
NSString *message = error.localizedDescription;
NSObject *details = error.userInfo[@"details"];
}
// ...
}
self->_resultField.text = result.data[@"text"];
}];
Web
var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
var sanitizedMessage = result.data.text;
});
Web
import { getFunctions, httpsCallable } from "firebase/functions";
const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
/** @type {any} */
const data = result.data;
const sanitizedMessage = data.text;
});
Kotlin
private fun addMessage(text: String): Task<String> { // Create the arguments to the callable function. val data = hashMapOf( "text" to text, "push" to true, ) return functions .getHttpsCallable("addMessage") .call(data) .continueWith { task -> // This continuation runs on either success or failure, but if the task // has failed then result will throw an Exception which will be // propagated down. val result = task.result?.data as String result } }
Java
private Task<String> addMessage(String text) { // Create the arguments to the callable function. Map<String, Object> data = new HashMap<>(); data.put("text", text); data.put("push", true); return mFunctions .getHttpsCallable("addMessage") .call(data) .continueWith(new Continuation<HttpsCallableResult, String>() { @Override public String then(@NonNull Task<HttpsCallableResult> task) throws Exception { // This continuation runs on either success or failure, but if the task // has failed then getResult() will throw an Exception which will be // propagated down. String result = (String) task.getResult().getData(); return result; } }); }
Dart
final result = await FirebaseFunctions.instance.httpsCallable('addMessage').call(
{
"text": text,
"push": true,
},
);
_response = result.data as String;
C++
firebase::Future<firebase::functions::HttpsCallableResult> AddMessage(
const std::string& text) {
// Create the arguments to the callable function.
firebase::Variant data = firebase::Variant::EmptyMap();
data.map()["text"] = firebase::Variant(text);
data.map()["push"] = true;
// Call the function and add a callback for the result.
firebase::functions::HttpsCallableReference doSomething =
functions->GetHttpsCallable("addMessage");
return doSomething.Call(data);
}
Unity
private Task<string> addMessage(string text) {
// Create the arguments to the callable function.
var data = new Dictionary<string, object>();
data["text"] = text;
data["push"] = true;
// Call the function and extract the operation from the result.
var function = functions.GetHttpsCallable("addMessage");
return function.CallAsync(data).ContinueWith((task) => {
return (string) task.Result.Data;
});
}
Gérer les erreurs sur le client
Le client reçoit une erreur si le serveur en a généré une ou si la promesse résultante a été refusée.
Si l'erreur renvoyée par la fonction est de type function.https.HttpsError, le client reçoit les erreurs code, message et details de l'erreur du serveur. Sinon, l'erreur contient le message INTERNAL et le code INTERNAL. Consultez les conseils pour savoir comment gérer les erreurs dans votre fonction appelable.
Swift
if let error = error as NSError? {
if error.domain == FunctionsErrorDomain {
let code = FunctionsErrorCode(rawValue: error.code)
let message = error.localizedDescription
let details = error.userInfo[FunctionsErrorDetailsKey]
}
// ...
}
Objective-C
if (error) {
if ([error.domain isEqual:@"com.firebase.functions"]) {
FIRFunctionsErrorCode code = error.code;
NSString *message = error.localizedDescription;
NSObject *details = error.userInfo[@"details"];
}
// ...
}
Web
var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
var sanitizedMessage = result.data.text;
})
.catch((error) => {
// Getting the Error details.
var code = error.code;
var message = error.message;
var details = error.details;
// ...
});
Web
import { getFunctions, httpsCallable } from "firebase/functions";
const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
/** @type {any} */
const data = result.data;
const sanitizedMessage = data.text;
})
.catch((error) => {
// Getting the Error details.
const code = error.code;
const message = error.message;
const details = error.details;
// ...
});
Kotlin
addMessage(inputMessage) .addOnCompleteListener { task -> if (!task.isSuccessful) { val e = task.exception if (e is FirebaseFunctionsException) { val code = e.code val details = e.details } } }
Java
addMessage(inputMessage) .addOnCompleteListener(new OnCompleteListener<String>() { @Override public void onComplete(@NonNull Task<String> task) { if (!task.isSuccessful()) { Exception e = task.getException(); if (e instanceof FirebaseFunctionsException) { FirebaseFunctionsException ffe = (FirebaseFunctionsException) e; FirebaseFunctionsException.Code code = ffe.getCode(); Object details = ffe.getDetails(); } } } });
Dart
try {
final result =
await FirebaseFunctions.instance.httpsCallable('addMessage').call();
} on FirebaseFunctionsException catch (error) {
print(error.code);
print(error.details);
print(error.message);
}
C++
void OnAddMessageCallback(
const firebase::Future<firebase::functions::HttpsCallableResult>& future) {
if (future.error() != firebase::functions::kErrorNone) {
// Function error code, will be kErrorInternal if the failure was not
// handled properly in the function call.
auto code = static_cast<firebase::functions::Error>(future.error());
// Display the error in the UI.
DisplayError(code, future.error_message());
return;
}
const firebase::functions::HttpsCallableResult* result = future.result();
firebase::Variant data = result->data();
// This will assert if the result returned from the function wasn't a string.
std::string message = data.string_value();
// Display the result in the UI.
DisplayResult(message);
}
// ...
// ...
auto future = AddMessage(message);
future.OnCompletion(OnAddMessageCallback);
// ...
Unity
addMessage(text).ContinueWith((task) => {
if (task.IsFaulted) {
foreach (var inner in task.Exception.InnerExceptions) {
if (inner is FunctionsException) {
var e = (FunctionsException) inner;
// Function error code, will be INTERNAL if the failure
// was not handled properly in the function call.
var code = e.ErrorCode;
var message = e.ErrorMessage;
}
}
} else {
string result = task.Result;
}
});
Recommandation : Prévenez les abus avec App Check
Avant de lancer votre application, vous devez activer App Check pour vous assurer que seules vos applications peuvent accéder à vos points de terminaison de fonction appelables.