Chiamare funzioni dall'app

2ª gen. 1ª gen.

Gli SDK client Cloud Functions for Firebase ti consentono di chiamare le funzioni direttamente da un'app Firebase. Per chiamare una funzione dalla tua app in questo modo, scrivi e implementa una funzione HTTP Callable in Cloud Functions, quindi aggiungi la logica client per chiamare la funzione dalla tua app.

È importante tenere presente che le funzioni richiamabili HTTP sono simili, ma non identiche, alle funzioni HTTP. Per utilizzare le funzioni chiamabili HTTP, devi utilizzare l'SDK client per la tua piattaforma insieme all'API di backend (o implementare il protocollo). Le funzioni chiamabili presentano questa differenza fondamentale rispetto alle funzioni HTTP:

• Con i token richiamabili, Firebase Authentication, FCM e App Check, se disponibili, vengono inclusi automaticamente nelle richieste.
• Il trigger deserializza automaticamente il corpo della richiesta e convalida i token di autenticazione.

L'SDK Firebase per Cloud Functions di seconda generazione e versioni successive interagisce con queste versioni minime dell'SDK client Firebase per supportare le funzioni chiamabili HTTPS:

• Firebase SDK per le piattaforme Apple 11.15.0
• SDK Firebase per Android 21.2.1
• SDK web modulare Firebase v. 9.7.0

Se vuoi aggiungere funzionalità simili a un'app creata su una piattaforma non supportata, consulta le specifiche del protocollo per https.onCall. Il resto di questa guida fornisce istruzioni su come scrivere, eseguire il deployment e chiamare una funzione chiamabile HTTP per piattaforme Apple, Android, web, C++ e Unity.

Scrivi ed esegui il deployment della funzione chiamabile

Gli esempi di codice in questa sezione si basano su un esempio di guida rapida completo che mostra come inviare richieste a una funzione lato server e ottenere una risposta utilizzando uno degli SDK client. Per iniziare, importa i moduli richiesti:

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");
index.js

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
main.py

Utilizza il gestore delle richieste per la tua piattaforma (functions.https.onCall) o on_call) per creare una funzione richiamabile HTTPS. Questo metodo accetta un parametro di richiesta:

Node.js

// Saves a message to the Firebase Realtime Database but sanitizes the
// text by removing swearwords.
exports.addmessage = onCall((request) => {
  // ...
});
index.js

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."""
main.py

Il parametro request contiene i dati trasmessi dall'app client, nonché un contesto aggiuntivo come lo stato di autenticazione. Per una funzione chiamabile che salva un messaggio di testo in Realtime Database, ad esempio, data potrebbe contenere il testo del messaggio, insieme alle informazioni di autenticazione in 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;
index.js

Python

# Message text passed from the client.
text = req.data["text"]
main.py
# 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", "")
main.py

La distanza tra la posizione della funzione chiamabile e quella del client chiamante può creare latenza di rete. Per ottimizzare il rendimento, valuta la possibilità di specificare la posizione della funzione, se applicabile, e assicurati di allineare la posizione della funzione chiamabile alla posizione impostata quando inizializzi l'SDK sul lato client.

Se vuoi, puoi allegare un'attestazione App Check per proteggere le tue risorse di backend da comportamenti illeciti, come fatturazione fraudolenta o phishing. Vedi Attivare l'applicazione forzata di App Check per Cloud Functions.

Nota: utilizza solo le API di backend functions.https o firebase_functions.https_fn per scrivere funzioni richiamabili. L'API trigger HTTP è completamente separata e non interoperabile con le funzioni chiamabili.

Restituisci il risultato

Per inviare i dati al client, restituisci dati che possono essere codificati in formato JSON. Ad esempio, per restituire il risultato di un'operazione di addizione:

Node.js

// returning result.
return {
  firstNumber: firstNumber,
  secondNumber: secondNumber,
  operator: "+",
  operationResult: firstNumber + secondNumber,
};
index.js

Python

return {
    "firstNumber": first_number,
    "secondNumber": second_number,
    "operator": "+",
    "operationResult": first_number + second_number
}
main.py

Il testo sanificato dell'esempio di testo del messaggio viene restituito sia al client sia a Realtime Database. In Node.js, questa operazione può essere eseguita in modo asincrono utilizzando una promessa 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};
})
index.js

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}
main.py

Inviare e ricevere risultati di streaming

Le funzioni richiamabili dispongono di meccanismi per la gestione dei risultati di streaming. Se hai un caso d'uso che richiede lo streaming, puoi configurarlo nella richiesta richiamabile e poi utilizzare il metodo appropriato dell'SDK client per chiamare la funzione.

Inviare i risultati dello streaming

Per trasmettere in streaming in modo efficiente i risultati generati nel tempo, ad esempio da una serie di richieste API separate o da un'API di IA generativa, controlla la proprietà acceptsStreaming nella richiesta chiamabile. Quando questa proprietà è impostata su true, puoi trasmettere in streaming i risultati al client con response.sendChunk().

Ad esempio, se un'app deve recuperare i dati delle previsioni meteo per più località, la funzione richiamabile può inviare separatamente le previsioni di ogni località ai client che hanno richiesto una risposta in streaming, anziché farli attendere fino a quando tutte le richieste di previsione non sono state risolte:

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);
});
index.js

Tieni presente che il funzionamento di response.sendChunk() dipende da alcuni dettagli della richiesta del cliente:

1. Se il client richiede una risposta in streaming: response.sendChunk(data) invia immediatamente il frammento di dati.

2. Se il client non richiede una risposta di streaming: response.sendChunk() non fa nulla per quella chiamata. La risposta completa viene inviata una volta che tutti i dati sono pronti.

Per determinare se il client richiede una risposta dinamica, controlla la proprietà request.acceptsStreaming. Ad esempio, se request.acceptsStreaming è false, potresti decidere di saltare qualsiasi lavoro che richiede molte risorse specificamente correlato alla preparazione o all'invio di singoli chunk, poiché il client non si aspetta una pubblicazione incrementale.

Ricevere i risultati dello streaming

In uno scenario tipico, il client richiede lo streaming con il metodo .stream e poi scorre i risultati:

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);
index.html

Esegui il ciclo iterativo nell'iterabile asincrono stream come mostrato. L'attesa della promessa data indica al client che la richiesta è stata completata

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)
    }
  }
}
MainActivity.kt

Per utilizzare la funzione di estensione asFlow(), aggiungi la libreria org.jetbrains.kotlinx:kotlinx-coroutines-reactive come dipendenza al file build.gradle(.kts) dell'app.

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() {

  }
});
MainActivity.java

Configurare CORS (Cross-Origin Resource Sharing)

Utilizza l'opzione cors per controllare quali origini possono accedere alla tua funzione.

Per impostazione predefinita, le funzioni chiamabili hanno CORS configurato per consentire le richieste da tutte le origini. Per consentire alcune richieste multiorigine, ma non tutte, passa un elenco di domini specifici o espressioni regolari che devono essere consentiti. Ad esempio:

Node.js

const { onCall } = require("firebase-functions/v2/https");

exports.getGreeting = onCall(
  { cors: [/firebase\.com$/, "https://flutter.com"] },
  (request) => {
    return "Hello, world!";
  }
);

Per vietare le richieste multiorigine, imposta il criterio cors su false.

Gestisci gli errori

Per garantire che il client riceva dettagli utili sugli errori, restituisci gli errori da una funzione chiamabile generando (o per Node.js restituendo una promessa rifiutata con) un'istanza di functions.https.HttpsError o https_fn.HttpsError. L'errore ha un attributo code che può essere uno dei valori elencati in gRPC Codici di stato. Gli errori hanno anche una stringa message, che per impostazione predefinita è una stringa vuota. Possono anche avere un campo details facoltativo con un valore arbitrario. Se dalle tue funzioni viene generato un errore diverso da un errore HTTPS, il client riceve invece un errore con il messaggio INTERNAL e il codice internal.

Ad esempio, una funzione potrebbe generare errori di convalida dei dati e di autenticazione con messaggi di errore da restituire al client chiamante:

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.");
}
index.js

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.")
main.py

Esegui il deployment della funzione chiamabile

Dopo aver salvato una funzione chiamabile completata in index.js, viene eseguito il deployment insieme a tutte le altre funzioni quando esegui firebase deploy. Per eseguire il deployment solo del chiamabile, utilizza l'argomento --only come mostrato per eseguire deployment parziali:

firebase deploy --only functions:addMessage

Se si verificano errori di autorizzazione durante il deployment delle funzioni, assicurati che i ruoli IAM appropriati siano assegnati all'utente che esegue i comandi di deployment.

Configura l'ambiente di sviluppo del client

Assicurati di soddisfare tutti i prerequisiti, quindi aggiungi le dipendenze e le librerie client necessarie alla tua app.

iOS+

Segui le istruzioni per aggiungere Firebase alla tua app Apple.

Utilizza Swift Package Manager per installare e gestire le dipendenze di Firebase.

Consulta la nostra guida all'installazione per scoprire i diversi modi in cui puoi aggiungere gli SDK Firebase al tuo progetto Apple, tra cui l'importazione diretta dei framework e l'utilizzo di CocoaPods.

1. In Xcode, con il progetto dell'app aperto, vai a File > Add Packages (File > Aggiungi pacchetti).
2. Quando richiesto, aggiungi il repository dell'SDK delle piattaforme Apple di Firebase:

  https://github.com/firebase/firebase-ios-sdk.git

Nota:i nuovi progetti devono utilizzare la versione dell'SDK predefinita (più recente), ma puoi scegliere una versione precedente, se necessario.
3. Scegli la raccolta Cloud Functions.
4. Aggiungi il flag -ObjC alla sezione Altri flag del linker delle impostazioni di build del target.
5. Al termine, Xcode inizierà automaticamente a risolvere e a scaricare le tue dipendenze in background.

Web

1. Segui le istruzioni per aggiungere Firebase alla tua app web. Assicurati di eseguire il seguente comando dal terminale:

   npm install firebase@11.10.0 --save

2. Richiedi manualmente sia Firebase Core che 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

1. Segui le istruzioni per aggiungere Firebase alla tua app Android.

2. Nel file Gradle (a livello di app) del modulo (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria Cloud Functions per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare il controllo delle versioni della libreria.

   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")
   }

   Utilizzando la Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

   (Alternativa)  Aggiungi le dipendenze della libreria Firebase senza utilizzare BoM

   Se scegli di non utilizzare la Firebase BoM, devi specificare ogni versione della libreria Firebase nella riga della dipendenza.

   Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo vivamente di utilizzare la BoM per gestire le versioni delle librerie, in modo da garantire la compatibilità di tutte le versioni.

   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")
   }

   Cerchi un modulo della libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono fare affidamento sul modulo della libreria principale (per i dettagli, consulta le domande frequenti su questa iniziativa).

Inizializza l'SDK client

Inizializza un'istanza di Cloud Functions:

Swift

lazy var functions = Functions.functions()
CloudAddCell.swift

Objective-C

@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];
CloudAddCell.m

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
MainActivity.kt

Java

private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();
MainActivity.java

Nota: per chiamare una funzione in esecuzione in una posizione diversa da quella predefinita us-central1, devi impostare il valore appropriato durante l'inizializzazione. Ad esempio, su Android inizializzeresti con getInstance(FirebaseApp app, String region).

Chiama la funzione

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
  }
}
CommentCell.swift

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;
  });
callable.js

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;
  });
fb_functions_call_add_message.js

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
        }
}
MainActivity.kt

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;
                }
            });
}
MainActivity.java

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;
  });
}

Gestire gli errori sul client

Il client riceve un errore se il server ha generato un errore o se la promessa risultante è stata rifiutata.

Se l'errore restituito dalla funzione è di tipo function.https.HttpsError, il client riceve gli errori code, message e details dall'errore del server. In caso contrario, l'errore contiene il messaggio INTERNAL e il codice INTERNAL. Consulta le indicazioni su come gestire gli errori nella funzione chiamabile.

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]
  }
  // ...
}
CloudAddCell.swift

Objective-C

if (error) {
  if ([error.domain isEqual:@"com.firebase.functions"]) {
    FIRFunctionsErrorCode code = error.code;
    NSString *message = error.localizedDescription;
    NSObject *details = error.userInfo[@"details"];
  }
  // ...
}
CloudAddCell.m

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;
    // ...
  });
callable.js

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;
    // ...
  });
fb_functions_call_add_message_error.js

Kotlin

addMessage(inputMessage)
    .addOnCompleteListener { task ->
        if (!task.isSuccessful) {
            val e = task.exception
            if (e is FirebaseFunctionsException) {
                val code = e.code
                val details = e.details
            }
        }
    }
MainActivity.kt

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();
        }
      }
    }
  });
MainActivity.java

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;
  }
});

Consigliato: previeni gli abusi con App Check

Prima di lanciare l'app, devi attivare App Check per assicurarti che solo le tue app possano accedere agli endpoint delle funzioni richiamabili.