Funkcje połączeń z aplikacji


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

Pamiętaj, że funkcje wywoływane przez HTTP są podobne, ale nie identyczne. Aby korzystać z funkcji wywoływanych przez HTTP, musisz użyć pakietu SDK klienta dla swojej platformy w połączeniu z interfejsem API backendu (lub zaimplementować protokół). Elementy wywołujące różnią się od tych funkcji HTTP:

  • W przypadku elementów wywoływanych tokeny uwierzytelniania Firebase, tokeny FCM i tokeny Sprawdzania aplikacji (jeśli są dostępne) są automatycznie uwzględniane w żądaniach.
  • Aktywator automatycznie zmienia treść żądania i weryfikuje tokeny uwierzytelniania.

Pakiet SDK Firebase dla Cloud Functions (2 generacji lub wyższej) współpracuje z tymi minimalnymi wersjami pakietu SDK Firebase, aby obsługiwać funkcje wywoływane przez HTTPS:

  • Pakiet SDK Firebase dla platform Apple 10.28.0
  • Pakiet SDK Firebase na Androida 21.0.0
  • Modułowy pakiet SDK Firebase w wersji 9.7.0

Jeśli chcesz dodać podobne funkcje 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 tworzenia, wdrażania i wywoływania funkcji HTTP dla platform Apple, Androida, aplikacji internetowych, C++ i Unity.

Tworzenie i wdrażanie funkcji wywoływanej

Użyj metody functions.https.onCall, aby utworzyć wywoływaną funkcję HTTPS. Ta metoda wykorzystuje 2 parametry: data i opcjonalnie 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 możliwej do wywołania, która zapisuje SMS-a w bazie danych czasu rzeczywistego, na przykład data może zawierać tekst wiadomości, a parametry context przedstawiają informacje dotyczące uwierzytelniania 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;

Odległość między lokalizacją funkcji wywoływanej a lokalizacją wywołującego klienta może powodować opóźnienia w sieci. Aby zoptymalizować wydajność, rozważ określenie lokalizacji funkcji w odpowiednich przypadkach i dopasuj lokalizację wywołania do lokalizacji ustawionej podczas inicjowania pakietu SDK po stronie klienta.

Opcjonalnie możesz dołączyć atest Sprawdzania aplikacji, aby chronić zasoby backendu przed nadużyciami takimi jak oszustwa rozliczeniowe czy wyłudzanie informacji. Zapoznaj się z artykułem na temat włączania wymuszania Sprawdzania aplikacji w Cloud Functions.

Odbieram wynik

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:

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

Aby zwrócić dane po operacji asynchronicznej, zwróć obietnicę. Dane zwrócone w efekcie obietnicy są wysyłane z powrotem do klienta. Możesz na przykład zwrócić oczyszczony tekst, który funkcja wywoływana zapisał w bazie danych czasu rzeczywistego:

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

Obsługa błędów

Aby zapewnić klientowi dostęp do przydatnych szczegółów błędu, zwróć błędy z możliwości wywołania przez wywołanie (lub zwrócenie odrzuconej obietnicy) instancji functions.https.HttpsError. Błąd ma atrybut code, który może być jedną z wartości wymienionych w miejscu functions.https.HttpsError. Błędy te zawierają też ciąg znaków message, który domyślnie jest pusty. Mogą też mieć opcjonalne pole details z dowolną wartością. Jeśli z Twoich funkcji zostanie zgłoszony błąd inny niż HttpsError, klient zamiast tego otrzyma komunikat o błędzie 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 w celu zwrócenia 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.");
}

Wdrażanie funkcji możliwej do wywołania

Gdy zapiszesz zakończoną funkcję wywoływaną w obiekcie index.js, zostanie ona wdrożona wraz ze wszystkimi innymi funkcjami po uruchomieniu firebase deploy. Aby wdrożyć tylko element możliwy do wywołania, użyj argumentu --only jak pokazano na ekranie do przeprowadzenia wdrożeń częściowych:

firebase deploy --only functions:addMessage

Jeśli podczas wdrażania funkcji wystąpią błędy uprawnień, sprawdź, czy do użytkownika wykonującego polecenia wdrożeniowe są przypisane odpowiednie role uprawnień.

Konfigurowanie środowiska programistycznego klienta

Sprawdź, czy spełniasz wymagania wstępne, a następnie dodaj do aplikacji wymagane zależności i biblioteki klienta.

iOS+

Wykonaj instrukcje dodawania Firebase do aplikacji Apple.

Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.

  1. Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > Dodaj pakiety).
  2. Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:
  3.   https://github.com/firebase/firebase-ios-sdk.git
  4. Wybierz bibliotekę Cloud Functions.
  5. Dodaj flagę -ObjC do sekcji Inne flagi łączące w ustawieniach kompilacji celu.
  6. Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie zależności w tle.

Web

  1. Wykonaj instrukcje dodawania Firebase do swojej aplikacji internetowej. Pamiętaj, aby uruchomić w terminalu to polecenie:
    npm install firebase@10.12.2 --save
    
  2. Ręczne wymaganie zarówno podstawowych funkcji 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 te instrukcje, aby dodać Firebase do swojej aplikacji internetowej.
  2. Dodaj do aplikacji podstawowe biblioteki klienta Firebase i Cloud Functions:
    <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. Możesz ręcznie wymagać zarówno podstawowych funkcji Firebase, jak i Cloud Functions:
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/functions");
    

Kotlin+KTX

  1. Wykonaj te instrukcje, aby dodać Firebase do swojej aplikacji na Androida.

  2. W pliku Gradle (na poziomie modułu) 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. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM.

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

    Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM

    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 swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne.

    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")
    }
    
    Szukasz modułu biblioteki korzystającego z usługi Kotlin? Od października 2023 r. (Firebase BoM 32.5.0) zarówno deweloperzy aplikacji Kotlin, jak i języki Java mogą korzystać z modułu biblioteki głównej (więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania o tę inicjatywę).

Java

  1. Wykonaj te instrukcje, aby dodać Firebase do swojej aplikacji na Androida.

  2. W pliku Gradle (na poziomie modułu) 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. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM.

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

    Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM

    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 swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne.

    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")
    }
    
    Szukasz modułu biblioteki korzystającego z usługi Kotlin? Od października 2023 r. (Firebase BoM 32.5.0) zarówno deweloperzy aplikacji Kotlin, jak i języki Java mogą korzystać z modułu biblioteki głównej (więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania o tę inicjatywę).

Dart

  1. Wykonaj instrukcje dodawania Firebase do aplikacji Flutter.

  2. Aby zainstalować wtyczkę, uruchom to polecenie z poziomu głównego projektu Flutter:

    flutter pub add cloud_functions
    
  3. Po zakończeniu ponownie skompiluj aplikację Flutter:

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

    import 'package:cloud_functions/cloud_functions.dart';
    

C++

W języku C++ z Androidem:

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

W języku C++ na platformach Apple:

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

Unity

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

Zainicjuj pakiet SDK klienta

Zainicjuj instancję Cloud Functions:

Swift

lazy var functions = Functions.functions()

Objective-C

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

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

Java

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

Dart

final functions = FirebaseFunctions.instance;

C++

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

Unity

functions = Firebase.Functions.DefaultInstance;

Wywołaj funkcję

Swift

functions.httpsCallable("addMessage").call(["text": inputField.text]) { result, error in
  if let error = error as NSError? {
    if error.domain == FunctionsErrorDomain {
      let code = FunctionsErrorCode(rawValue: error.code)
      let message = error.localizedDescription
      let details = error.userInfo[FunctionsErrorDetailsKey]
    }
    // ...
  }
  if let data = result?.data as? [String: Any], let text = data["text"] as? String {
    self.resultField.text = text
  }
}

Objective-C

[[_functions HTTPSCallableWithName:@"addMessage"] callWithObject:@{@"text": _inputField.text}
                                                      completion:^(FIRHTTPSCallableResult * _Nullable result, NSError * _Nullable error) {
  if (error) {
    if ([error.domain isEqual:@"com.firebase.functions"]) {
      FIRFunctionsErrorCode code = error.code;
      NSString *message = error.localizedDescription;
      NSObject *details = error.userInfo[@"details"];
    }
    // ...
  }
  self->_resultField.text = result.data[@"text"];
}];

Web

var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    var sanitizedMessage = result.data.text;
  });

Web

import { getFunctions, httpsCallable } from "firebase/functions";

const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    /** @type {any} */
    const data = result.data;
    const sanitizedMessage = data.text;
  });

Kotlin+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
        }
}

Java

private Task<String> addMessage(String text) {
    // Create the arguments to the callable function.
    Map<String, Object> data = new HashMap<>();
    data.put("text", text);
    data.put("push", true);

    return mFunctions
            .getHttpsCallable("addMessage")
            .call(data)
            .continueWith(new Continuation<HttpsCallableResult, String>() {
                @Override
                public String then(@NonNull Task<HttpsCallableResult> task) throws Exception {
                    // This continuation runs on either success or failure, but if the task
                    // has failed then getResult() will throw an Exception which will be
                    // propagated down.
                    String result = (String) task.getResult().getData();
                    return result;
                }
            });
}

Dart

    final result = await FirebaseFunctions.instance.httpsCallable('addMessage').call(
      {
        "text": text,
        "push": true,
      },
    );
    _response = result.data as String;

C++

firebase::Future<firebase::functions::HttpsCallableResult> AddMessage(
    const std::string& text) {
  // Create the arguments to the callable function.
  firebase::Variant data = firebase::Variant::EmptyMap();
  data.map()["text"] = firebase::Variant(text);
  data.map()["push"] = true;

  // Call the function and add a callback for the result.
  firebase::functions::HttpsCallableReference doSomething =
      functions->GetHttpsCallable("addMessage");
  return doSomething.Call(data);
}

Unity

private Task<string> addMessage(string text) {
  // Create the arguments to the callable function.
  var data = new Dictionary<string, object>();
  data["text"] = text;
  data["push"] = true;

  // Call the function and extract the operation from the result.
  var function = functions.GetHttpsCallable("addMessage");
  return function.CallAsync(data).ContinueWith((task) => {
    return (string) task.Result.Data;
  });
}

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

Klient otrzymuje błąd, jeśli serwer zwrócił błąd lub jeśli wynikowa obietnica została odrzucona.

Jeśli błąd zwrócony przez funkcję jest typu function.https.HttpsError, klient otrzyma błąd code, message i details z błędu serwera. W przeciwnym razie komunikat o błędzie zawiera komunikat INTERNAL i kod INTERNAL. Zapoznaj się ze 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]
  }
  // ...
}

Objective-C

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

Web

var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    var sanitizedMessage = result.data.text;
  })
  .catch((error) => {
    // Getting the Error details.
    var code = error.code;
    var message = error.message;
    var details = error.details;
    // ...
  });

Web

import { getFunctions, httpsCallable } from "firebase/functions";

const functions = getFunctions();
const addMessage = httpsCallable(functions, 'addMessage');
addMessage({ text: messageText })
  .then((result) => {
    // Read result of the Cloud Function.
    /** @type {any} */
    const data = result.data;
    const sanitizedMessage = data.text;
  })
  .catch((error) => {
    // Getting the Error details.
    const code = error.code;
    const message = error.message;
    const details = error.details;
    // ...
  });

Kotlin+KTX

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

Java

addMessage(inputMessage)
        .addOnCompleteListener(new OnCompleteListener<String>() {
            @Override
            public void onComplete(@NonNull Task<String> task) {
                if (!task.isSuccessful()) {
                    Exception e = task.getException();
                    if (e instanceof FirebaseFunctionsException) {
                        FirebaseFunctionsException ffe = (FirebaseFunctionsException) e;
                        FirebaseFunctionsException.Code code = ffe.getCode();
                        Object details = ffe.getDetails();
                    }
                }
            }
        });

Dart

try {
  final result =
      await FirebaseFunctions.instance.httpsCallable('addMessage').call();
} on FirebaseFunctionsException catch (error) {
  print(error.code);
  print(error.details);
  print(error.message);
}

C++

void OnAddMessageCallback(
    const firebase::Future<firebase::functions::HttpsCallableResult>& future) {
  if (future.error() != firebase::functions::kErrorNone) {
    // Function error code, will be kErrorInternal if the failure was not
    // handled properly in the function call.
    auto code = static_cast<firebase::functions::Error>(future.error());

    // Display the error in the UI.
    DisplayError(code, future.error_message());
    return;
  }

  const firebase::functions::HttpsCallableResult* result = future.result();
  firebase::Variant data = result->data();
  // This will assert if the result returned from the function wasn't a string.
  std::string message = data.string_value();
  // Display the result in the UI.
  DisplayResult(message);
}

// ...

// ...
  auto future = AddMessage(message);
  future.OnCompletion(OnAddMessageCallback);
  // ...

Unity

 addMessage(text).ContinueWith((task) => {
  if (task.IsFaulted) {
    foreach (var inner in task.Exception.InnerExceptions) {
      if (inner is FunctionsException) {
        var e = (FunctionsException) inner;
        // Function error code, will be INTERNAL if the failure
        // was not handled properly in the function call.
        var code = e.ErrorCode;
        var message = e.ErrorMessage;
      }
    }
  } else {
    string result = task.Result;
  }
});

Przed opublikowaniem aplikacji włącz Sprawdzanie aplikacji, aby mieć pewność, że tylko Twoje aplikacje mają dostęp do punktów końcowych funkcji, które można wywołać.