Chiamare funzioni dall'app


Gli SDK client di 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 esegui il deployment di una funzione chiamabile HTTP in Cloud Functions, quindi aggiungi la logica client per chiamare la funzione dalla tua app.

È importante tenere presente che le funzioni chiamabili 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). I chiamabili hanno queste chiavi differenza rispetto alle funzioni HTTP:

  • Con i chiamabili, i token 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 2a generazione e versioni successive interagisce con questi client Firebase Versioni minime dell'SDK per supportare le funzioni richiamabili HTTPS:

  • SDK Firebase per le piattaforme Apple 11.2.0
  • SDK Firebase per Android 21.0.0
  • SDK web modulare Firebase 9.7.0

Se vuoi aggiungere funzionalità simili a un'app creata su una piattaforma non supportata, consulta la specifica 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 le piattaforme Apple, Android, web, C++ e Unity.

Scrivere ed eseguire il deployment della funzione richiamabile

Utilizza functions.https.onCall per creare una funzione richiamabile HTTPS. Questo metodo richiede due parametri: data e context facoltativo:

  // Saves a message to the Firebase Realtime Database but sanitizes the
  // text by removing swearwords.
  exports.addMessage = functions.https.onCall((data, context) => {
    // ...
  });

Ad esempio, per una funzione richiamabile che salva un messaggio in Realtime Database, data potrebbe contenere il testo del messaggio, mentre i parametri context rappresentano le informazioni di autenticazione dell'utente:

// 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

Distanza tra la posizione della funzione richiamabile e la posizione del client chiamante può creare latenza di rete. Per ottimizzare il rendimento, valuta la possibilità di specificare la posizione della funzione dove applicabile e assicurati di allineare la posizione della chiamata con la posizione impostata quando inizializzi l'SDK lato client.

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

Invio del risultato in corso...

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

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

Per restituire i dati dopo un'operazione asincrona, restituisci una promessa. I dati resi dalla promessa vengono inviati al client. Ad esempio, puoi restituire il testo destrutturato scritto dalla funzione richiamabile in Realtime Database:

// 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

Gestire gli errori

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

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

// 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

Esegui il deployment della funzione richiamabile

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

firebase deploy --only functions:addMessage

Se si verificano errori relativi alle autorizzazioni durante il deployment delle funzioni, assicurati che: i ruoli IAM appropriati sono e assegnato 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 all'app Apple.

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

  1. In Xcode, con il progetto dell'app aperto, vai a File > Aggiungi pacchetti.
  2. Quando richiesto, aggiungi il repository dell'SDK delle piattaforme Apple Firebase:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Scegli la libreria Cloud Functions.
  4. Aggiungi il flag -ObjC alla sezione Altri flag 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@10.13.2 --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);

Web

  1. Segui le istruzioni per aggiungi Firebase alla tua app web.
  2. Aggiungi le librerie client Firebase core e Cloud Functions alla tua app: 
    <script src="https://www.gstatic.com/firebasejs/8.10.1/firebase.js"></script>
<script src="https://www.gstatic.com/firebasejs/8.10.1/firebase-functions.js"></script>

L'SDK Cloud Functions è disponibile anche come pacchetto npm.

  1. Esegui questo comando dal terminale: 
    npm install firebase@8.10.1 --save
  2. Richiedi manualmente sia Firebase Core che Cloud Functions: 
    const firebase = require("firebase");
// Required for side-effects
require("firebase/functions");

Kotlin+KTX

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

  2. Nel file Gradle del modulo (a livello di app) (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 delle librerie. 

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.3.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")
}

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

    (alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare il BoM

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

    Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare 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.0.0")
}
         Cerchi un modulo della libreria specifico per Kotlin? A partire da Ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono dipendono dal modulo principale della libreria (per i dettagli, consulta Domande frequenti su questa iniziativa).

Java

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

  2. Nel file Gradle del modulo (a livello di app) (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 delle librerie. 

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.3.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 Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase per Android.

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

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

    Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo consiglia di utilizzare BoM per gestire le versioni della libreria, in modo da garantire che tutte le versioni siano compatibili. 

    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.0.0")
}
         Cerchi un modulo della libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0), sia gli sviluppatori Kotlin sia quelli Java possono fare affidamento sul modulo della libreria principale (per maggiori dettagli, consulta le domande frequenti su questa iniziativa).

Dart

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

  2. Dalla directory principale del progetto Flutter, esegui il seguente comando per installare il plug-in:

    flutter pub add cloud_functions

  3. Al termine, ricrea l'applicazione Flutter:

    flutter run

  4. Una volta installato, puoi accedere al plug-in cloud_functions importandolo nel codice Dart:

    import 'package:cloud_functions/cloud_functions.dart';

C++

Per C++ con Android:

  1. Segui le istruzioni per aggiungere Firebase al tuo progetto C++.
  2. Aggiungi la raccolta firebase_functions al file CMakeLists.txt.

Per C++ con piattaforme Apple:

  1. Segui le istruzioni per aggiungere Firebase al tuo progetto C++.
  2. Aggiungi il pod Cloud Functions a Podfile: 
    pod 'Firebase/Functions'
  3. Salva il file ed esegui: 
    pod install
  4. Aggiungi i framework Firebase Core e Cloud Functions dall'SDK Firebase C++ al tuo progetto Xcode.
    • firebase.framework
    • firebase_functions.framework

Unity

  1. Segui le istruzioni per aggiungi Firebase al tuo progetto Unity.
  2. Aggiungi FirebaseFunctions.unitypackage dall'SDK Unity di Firebase al tuo progetto Unity.

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 

firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FUNCTIONS PROJECT ID ###'
  databaseURL: 'https://### YOUR DATABASE NAME ###.firebaseio.com',
});

// Initialize Cloud Functions through Firebase
var functions = firebase.functions();

Web 

const app = initializeApp({
  projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
});
const functions = getFunctions(app);

Kotlin+KTX 

private lateinit var functions: FirebaseFunctions
// ...
functions = Firebase.functions
MainActivity.kt

Java 

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

Dart 

final functions = FirebaseFunctions.instance;

C++

firebase::functions::Functions* functions;
// ...
functions = firebase::functions::Functions::GetInstance(app);

Unity

functions = Firebase.Functions.DefaultInstance;

Richiama 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+KTX 

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 codice INTERNAL. Consulta le indicazioni su come gestire gli errori nella funzione richiamabile.

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+KTX 

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

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