Funkcje nawiązywania połączeń z aplikacji


Cloud Functions for Firebase pakiety SDK klienta umożliwiają wywoływanie funkcji bezpośrednio z aplikacji Firebase. Aby w ten sposób wywołać funkcję z aplikacji, napisz i wdroż funkcję wywoływaną przez HTTP w Cloud Functions, a następnie dodaj logikę klienta, aby wywołać funkcję z aplikacji.

Pamiętaj, że funkcje wywoływane przez HTTP są podobne do funkcji HTTP, ale nie są z nimi tożsame. Aby używać funkcji wywoływanych przez HTTP, musisz używać pakietu SDK klienta dla swojej platformy wraz z interfejsem API backendu (lub zaimplementować protokół). Funkcje wywoływalne różnią się od funkcji HTTP tymi kluczowymi cechami:

  • W przypadku funkcji wywoływanych tokeny Firebase Authentication, FCM i App Check są automatycznie uwzględniane w żądaniach, gdy są dostępne.
  • Wywołanie automatycznie deserializuje treść żądania i weryfikuje tokeny uwierzytelniania.

Pakiet SDK Firebase na Cloud Functions 2 generacji i nowsze współpracuje z tymi minimalnymi wersjami pakietu SDK klienta Firebase, aby obsługiwać funkcje wywoływane przez HTTPS:

  • Firebase Pakiet SDK na platformy Apple w wersji 11.15.0
  • Firebase Pakiet SDK w wersji Android 21.2.1
  • Modułowy pakiet Firebase Web SDK w wersji 9.7.0

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

Pisanie i wdrażanie funkcji wywoływanej

Użyj functions.https.onCall, aby utworzyć funkcję wywoływaną przez HTTPS. Ta metoda przyjmuje 2 parametry: data i opcjonalny context:

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

W przypadku funkcji wywoływanej, która zapisuje wiadomość tekstową w Realtime Database, na przykład data może zawierać tekst wiadomości, a parametry context mogą reprezentować informacje o uwierzytelnianiu użytkownika:

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

Odległość między lokalizacją funkcji wywoływanej a lokalizacją klienta wywołującego może powodować opóźnienie sieciowe. Aby zoptymalizować skuteczność, w odpowiednich przypadkach określ lokalizację funkcji i upewnij się, że lokalizacja wywoływanego elementu jest zgodna z lokalizacją ustawioną podczas inicjowania pakietu SDK po stronie klienta.

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

Wysyłanie wyniku z powrotem

Aby odesłać dane do klienta, zwróć dane, które można zakodować w formacie JSON. Na przykład aby zwrócić wynik dodawania:

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

Aby zwrócić dane po operacji asynchronicznej, zwróć obietnicę. Dane zwrócone przez obietnicę są odsyłane do klienta. Możesz na przykład zwrócić oczyszczony tekst, który funkcja wywoływana napisała w 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

Obsługuj błędy

Aby mieć pewność, że klient otrzyma przydatne szczegóły błędu, zwracaj błędy z funkcji wywoływanej przez zgłoszenie (lub zwrócenie obietnicy odrzuconej z użyciem) instancji functions.https.HttpsError. Błąd ma atrybut code, który może przyjmować jedną z wartości wymienionych na stronie functions.https.HttpsError. Błędy mają też ciąg message, który domyślnie jest pusty. Mogą też zawierać opcjonalne pole details z dowolną wartością. Jeśli funkcje zwrócą błąd inny niż HttpsError, klient otrzyma błąd z komunikatem INTERNAL i kodem internal.

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

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

Wdrażanie funkcji wywoływanej

Po zapisaniu ukończonej funkcji wywoływanej w index.js jest ona wdrażana wraz z innymi funkcjami po uruchomieniu firebase deploy. Aby wdrożyć tylko funkcję wywoływaną, 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ń, sprawdź, czy użytkownikowi, który uruchamia polecenia wdrażania, 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+

Postępuj zgodnie z instrukcjami, 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 projektu.
  5. Gdy skończysz, Xcode zacznie automatycznie wyszukiwać i pobierać zależności w tle.

Web

  1. Wykonaj instrukcje, aby dodać Firebase do aplikacji internetowej. Pamiętaj, aby uruchomić w terminalu to polecenie: 
    npm install firebase@11.10.0 --save

  2. Ręczne wymaganie zarówno podstawowych usług Firebase, 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);

Web

  1. Wykonaj instrukcje, aby dodać Firebase do aplikacji internetowej.
  2. Dodaj do aplikacji biblioteki podstawowe Firebase i Cloud Functionsklienta: 
    <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>

Pakiet SDK Cloud Functions jest też dostępny jako pakiet npm.

  1. Uruchom w terminalu to polecenie: 
    npm install firebase@8.10.1 --save
  2. Ręczne wymaganie zarówno podstawowych usług Firebase, jak i Cloud Functions: 
    const firebase = require("firebase");
// Required for side-effects
require("firebase/functions");

Kotlin

  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ść z biblioteką Cloud Functions na Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji biblioteki. 

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

    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życia BoM

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

    Pamiętaj, że jeśli w aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z 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:21.2.1")
}
         Szukasz modułu biblioteki przeznaczonego specjalnie dla języka Kotlin? Od października 2023 r. Firebase BoM(wersja 32.5.0) deweloperzy korzystający z języków Kotlin i Java mogą używać głównego modułu biblioteki (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania dotyczące tej inicjatywy).

Java

  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ść z biblioteką Cloud Functions na Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji biblioteki. 

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

    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życia BoM

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

    Pamiętaj, że jeśli w aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z 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:21.2.1")
}
         Szukasz modułu biblioteki przeznaczonego specjalnie dla języka Kotlin? Od października 2023 r. Firebase BoM(wersja 32.5.0) deweloperzy korzystający z języków Kotlin i Java mogą używać głównego modułu biblioteki (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania dotyczące tej inicjatywy).

Dart

  1. Postępuj zgodnie z instrukcjami, aby dodać Firebase do aplikacji Flutter.

  2. W katalogu głównym projektu Flutter uruchom to polecenie, aby zainstalować wtyczkę:

    flutter pub add cloud_functions

  3. Po zakończeniu przebuduj aplikację Flutter:

    flutter run

  4. Po zainstalowaniu możesz uzyskać dostęp do cloud_functions wtyczki, importując ją w kodzie Dart:

    import 'package:cloud_functions/cloud_functions.dart';

C++

W przypadku C++ na Androidzie:

  1. Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu C++.
  2. Dodaj bibliotekę firebase_functions do pliku CMakeLists.txt.

W przypadku C++ na platformach Apple:

  1. Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu C++.
  2. Dodaj poda Cloud Functions do Podfile: 
    pod 'Firebase/Functions'
  3. Zapisz plik, a następnie uruchom: 
    pod install
  4. Dodaj do projektu Xcode podstawowe i Cloud Functions frameworki Firebase z Firebase C++ pakietu SDK.
    • firebase.framework
    • firebase_functions.framework

Unity

  1. Postępuj zgodnie z instrukcjami, aby dodać Firebase do projektu w Unity.
  2. Dodaj FirebaseFunctions.unitypackage z Firebase Unity pakietu SDK do projektu Unity.

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 

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 

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;

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. Zapoznaj się z wskazówkami dotyczącymi obsługi błędów w funkcji wywoływanej.

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: zapobiegaj nadużyciom za pomocą App Check

Przed uruchomieniem aplikacji włącz App Check, aby mieć pewność, że tylko Twoje aplikacje będą miały dostęp do punktów końcowych funkcji wywoływalnych.