Funkcje nawiązywania połączeń z aplikacji

Pakiety SDK klienta Cloud Functions for Firebase umożliwiają wywoływanie funkcji bezpośrednio z aplikacji w Firebase. Aby wywołać funkcję z aplikacji w ten sposób, napisz i wdróż funkcję HTTP Callable w Cloud Functions, a następnie dodaj logikę klienta, która będzie wywoływać tę funkcję z aplikacji.

Pamiętaj, że funkcje HTTP Callable są podobne do funkcji HTTP, ale nie są z nimi identyczne. Aby korzystać z funkcji HTTP Callable, musisz używać pakietu SDK klienta na swojej platformie razem z interfejsem API backendu (lub zaimplementować protokół). Funkcje Callable różnią się od funkcji HTTP tymi kluczowymi cechami:

  • W przypadku funkcji Callable tokeny Firebase Authentication, tokeny FCM i tokeny App Check są automatycznie dołączane do żądań, gdy są dostępne.
  • Wywołanie automatycznie deserializuje treść żądania i weryfikuje tokeny uwierzytelniania.

Pakiet Firebase SDK dla Cloud Functions 2. generacji i nowszych współpracuje z tymi minimalnymi wersjami pakietu SDK klienta Firebase, aby obsługiwać funkcje HTTPS Callable:

  • Firebase SDK na platformy Apple 12.12.0
  • Firebase SDK dla Android 22.1.1
  • Modułowy pakiet SDK Firebase Web w wersji 9.7.0

Jeśli chcesz dodać podobną funkcję do aplikacji utworzonej na nieobsługiwanej platformie, zapoznaj się ze specyfikacją protokołu dla https.onCall. W pozostałej części tego przewodnika znajdziesz instrukcje dotyczące pisania, wdrażania i wywoływania funkcji HTTP Callable na platformach Apple, Androidzie, w internecie, C++ i Unity.

Pisanie i wdrażanie funkcji Callable

Przykłady kodu w tej sekcji są oparte na kompletnym przykładzie szybkiego startu , który pokazuje, jak wysyłać żądania do funkcji po stronie serwera i uzyskiwać odpowiedź za pomocą jednego z pakietów SDK klienta. Aby rozpocząć, zaimportuj wymagane moduły:

Node.js

// Dependencies for callable functions.
const {onCall, HttpsError} = require("firebase-functions/https");
const {logger} = require("firebase-functions");

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

Aby utworzyć funkcję HTTPS Callable, użyj modułu obsługi żądań na swojej platformie (functions.https.onCall) lub on_call) . Ta metoda przyjmuje parametr żądania:

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

Parametr request zawiera dane przekazywane z aplikacji klienta oraz dodatkowy kontekst, np. stan uwierzytelnienia. W przypadku funkcji Callable, która zapisuje wiadomość tekstową w Realtime Database, na przykład, data może zawierać tekst wiadomości oraz informacje o uwierzytelnieniu w 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

Odległość między lokalizacją funkcji Callable a lokalizacją klienta wywołującego może powodować opóźnienie sieciowe. Aby zoptymalizować wydajność, rozważ określenie lokalizacji funkcji, jeśli to możliwe, i upewnij się, że lokalizacja funkcji Callable jest zgodna z lokalizacją ustawioną podczas inicjowania pakietu SDK po stronie klienta.

Opcjonalnie możesz dołączyć atest App Check, aby chronić swoje zasoby backendu przed nadużyciami, takimi jak oszukańcze płatności czy wyłudzanie informacji. Zobacz Włączanie App Check egzekwowania dla Cloud Functions.

Wysyłanie wyniku

Aby wysłać dane z powrotem do klienta, zwróć dane, które można zakodować w formacie JSON. Aby na przykład zwrócić wynik operacji dodawania:

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

Oczyszczony tekst z przykładu tekstu wiadomości jest zwracany zarówno do klienta i do Realtime Database. W Node.js można to zrobić asynchronicznie za pomocą obietnicy 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

Funkcja musi zwracać wartość lub, w przypadku Node.js, obietnicę, która jest rozwiązywana z wartością. W przeciwnym razie funkcja może się zakończyć, zanim dane zostaną wysłane z powrotem do klienta. Wskazówki znajdziesz w artykule Zakończanie funkcji.

Wysyłanie i odbieranie wyników przesyłania strumieniowego

Funkcje Callable mają mechanizmy obsługi wyników przesyłania strumieniowego. Jeśli masz przypadek użycia, który wymaga przesyłania strumieniowego, możesz skonfigurować przesyłanie strumieniowe w żądaniu Callable, a następnie użyć odpowiedniej metody z pakietu SDK klienta, aby wywołać funkcję.

Wysyłanie wyników przesyłania strumieniowego

Aby efektywnie przesyłać strumieniowo wyniki generowane z upływem czasu, np. z wielu oddzielnych żądań interfejsu API lub interfejsu API generatywnej AI, sprawdź właściwość acceptsStreaming w żądaniu Callable. Gdy ta właściwość jest ustawiona na true, możesz przesyłać strumieniowo wyniki z powrotem do klienta za pomocą response.sendChunk().

Jeśli na przykład aplikacja musi pobrać dane prognozy pogody dla wielu lokalizacji, funkcja Callable może wysyłać prognozę dla każdej lokalizacji osobno do klientów, którzy poprosili o odpowiedź przesyłaną strumieniowo, zamiast czekać, aż wszystkie żądania prognozy zostaną rozwiązane:

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

Pamiętaj, że sposób działania response.sendChunk() zależy od pewnych szczegółów żądania klienta:

  1. Jeśli klient zażąda odpowiedzi przesyłanej strumieniowo: response.sendChunk(data) natychmiast wysyła fragment danych.

  2. Jeśli klient nie zażąda odpowiedzi przesyłanej strumieniowo: response.sendChunk() nie wykonuje żadnych działań w przypadku tego wywołania. Pełna odpowiedź jest wysyłana, gdy wszystkie dane są gotowe.

Aby sprawdzić, czy klient żąda odpowiedzi przesyłanej strumieniowo, sprawdź właściwość request.acceptsStreaming. Jeśli na przykład request.acceptsStreaming ma wartość false, możesz pominąć wszelkie zadania wymagające dużej ilości zasobów, które są związane z przygotowywaniem lub wysyłaniem poszczególnych fragmentów, ponieważ klient nie oczekuje dostawy przyrostowej.

Odbieranie wyników przesyłania strumieniowego

W typowym scenariuszu klient żąda przesyłania strumieniowego za pomocą metody .stream, a następnie iteruje po wynikach:

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

Przejdź w pętli przez asynchroniczny element iterowalny stream, jak pokazano poniżej. Oczekiwanie na obietnicę data wskazuje klientowi, że żądanie zostało zakończone.

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

Aby użyć funkcji rozszerzenia asFlow(), dodaj bibliotekę org.jetbrains.kotlinx:kotlinx-coroutines-reactive jako zależność do pliku build.gradle(.kts) aplikacji.

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

Konfigurowanie CORS (współdzielenia zasobów między serwerami z różnych domen)

Użyj opcji cors, aby określić, które źródła mogą uzyskiwać dostęp do Twojej funkcji.

Domyślnie funkcje Callable mają skonfigurowane CORS tak, aby zezwalać na żądania ze wszystkich źródeł. Aby zezwolić na niektóre żądania z różnych źródeł, ale nie na wszystkie, przekaż listę konkretnych domen lub wyrażeń regularnych, które powinny być dozwolone. Przykład:

Node.js

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

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

Aby zabronić żądań z różnych źródeł, ustaw zasadę cors na false.

Obsługuj błędy

Aby mieć pewność, że klient otrzyma przydatne szczegóły błędu, zwróć błędy z funkcji Callable, zgłaszając (lub w przypadku Node.js zwracając obietnicę odrzuconą z) instancję functions.https.HttpsError lub https_fn.HttpsError. Błąd ma atrybut code, który może być jedną z wartości wymienionych w gRPC kodach stanu. Błędy mają też ciąg znaków message, który domyślnie jest pusty. Mogą też mieć opcjonalne pole details z dowolną wartością. Jeśli funkcja zgłosi błąd inny niż błąd HTTPS, klient otrzyma błąd z komunikatem INTERNAL i kodem internal.

Funkcja może na przykład zgłaszać błędy weryfikacji danych i uwierzytelniania z komunikatami o błędach, które mają być zwracane do klienta wywołującego:

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

Wdrażanie funkcji Callable

Gdy zapiszesz ukończoną funkcję Callable w pliku index.js, zostanie ona wdrożona razem z innymi funkcjami po uruchomieniu polecenia firebase deploy. Aby wdrożyć tylko funkcję Callable, użyj argumentu --only, jak pokazano poniżej, aby wykonać częściowe wdrożenia:

firebase deploy --only functions:addMessage

Jeśli podczas wdrażania funkcji wystąpią błędy uprawnień, upewnij się, że użytkownikowi, który uruchamia polecenia wdrożenia, przypisano odpowiednie role IAM.

Konfigurowanie środowiska programistycznego klienta

Upewnij się, że spełniasz wszystkie wymagania wstępne, a następnie dodaj do aplikacji wymagane zależności i biblioteki klienta.

iOS+

Wykonaj instrukcje, aby dodać Firebase do aplikacji Apple.

Do instalacji zależności Firebase i do zarządzania nimi możesz używać menedżera pakietów Swift.

  1. Po otwarciu projektu aplikacji wybierz w Xcode opcję File > Add Packages (Plik > Dodaj pakiety).
  2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę Cloud Functions.
  4. Dodaj flagę -ObjC do sekcji Other Linker Flags (Inne flagi linkera) w ustawieniach kompilacji celu.
  5. Gdy skończysz, Xcode zacznie automatycznie wyszukiwać i pobierać Twoje zależności w tle.

Web

  1. Wykonaj instrukcje, aby dodać Firebase do aplikacji internetowej. Upewnij się, że w terminalu uruchamiasz to polecenie: 
    npm install firebase@12.12.0 --save

  2. Ręcznie wymagaj zarówno Firebase Core, jak i 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. Wykonaj instrukcje, aby dodać Firebase do aplikacji na Androida.

  2. W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), dodaj zależność od biblioteki Cloud Functions na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie Firebase Android BoM. 

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

    Gdy korzystamy z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie)  Dodaj zależności biblioteki Firebase bez używania BoM

    Jeśli nie chcesz używać Firebase BoM, musisz określić wersję każdej biblioteki Firebase w wierszu zależności.

    Pamiętaj, że jeśli w aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji. 

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

Inicjowanie pakietu SDK klienta

Zainicjuj instancję 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

Wywoływanie funkcji

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

Obsługa błędów po stronie klienta

Klient otrzymuje błąd, jeśli serwer zgłosił błąd lub jeśli obietnica została odrzucona.

Jeśli błąd zwrócony przez funkcję jest typu function.https.HttpsError, klient otrzymuje błąd code, message, i details z błędu serwera. W przeciwnym razie błąd zawiera komunikat INTERNAL i kod INTERNAL. Wskazówki dotyczące obsługi błędów w funkcji Callable znajdziesz tutaj.

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

Zalecane: zapobieganie nadużyciom za pomocą App Check

Zanim opublikujesz aplikację, włącz App Check , aby mieć pewność, że tylko Twoje aplikacje będą mogły uzyskiwać dostęp do punktów końcowych funkcji Callable.