Funkcje połączeń z aplikacji


Pakiety SDK klienta Cloud Functions dla Firebase umożliwiają wywoływanie funkcji bezpośrednio z aplikacji Firebase. Aby wywoływać funkcję z aplikacji w ten sposób, napisz i wdróż funkcję wywoływaną przez HTTP w Cloud Functions, a następnie 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 używać funkcji wywoływanych przez HTTP, musisz używać na swojej platformie pakietu SDK klienta razem z interfejsem API backendu (lub zaimplementować protokół). Elementy wywołujące różnią się od funkcji HTTP tymi kluczowymi różnicami:

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

Pakiet SDK Firebase dla Cloud Functions (2 generacji i nowszych) współdziała z tymi minimalnymi wersjami pakietu SDK klienta Firebase, aby obsługiwać funkcje wywoływane przez HTTPS:

  • Pakiet SDK Firebase na platformy Apple 10.26.0
  • Pakiet SDK Firebase na Androida 21.0.0
  • Modułowy pakiet SDK internetowy Firebase 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 pozostałej części tego przewodnika znajdziesz instrukcje tworzenia, wdrażania i wywoływania funkcji HTTP na platformach Apple, Androidzie, internecie, C++ i Unity.

Napisz i wdróż funkcję wywoływaną

Użyj functions.https.onCall, aby utworzyć funkcję wywoływaną przez HTTPS. Ta metoda przyjmuje 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 wiadomość tekstową w Bazie danych czasu rzeczywistego, np. data może zawierać tekst komunikatu, a parametry context przedstawiają informacje 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 możliwej do wywołania a lokalizacją klienta wywołującego może powodować opóźnienia w sieci. Aby zoptymalizować wydajność, zastanów się nad określeniem lokalizacji funkcji tam, gdzie ma to zastosowanie. Pamiętaj, aby podczas inicjowania pakietu SDK po stronie klienta dopasować lokalizację elementu wywołującego do lokalizacji ustawionej.

Opcjonalnie możesz dołączyć poświadczenie sprawdzania aplikacji, aby chronić zasoby backendu przed nadużyciami, takimi jak oszustwa związane z płatnościami czy wyłudzanie informacji. Zobacz Włączanie wymuszania Sprawdzania aplikacji w Cloud Functions.

Odsyłam wynik

Aby wysłać dane z powrotem do klienta, zwróć dane, które można zakodować w formacie JSON. Aby np. 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 zwracane przez obietnicę są wysyłane z powrotem do klienta. Możesz na przykład zwrócić przetworzony tekst zapisany przez funkcję z możliwością wywołania do bazy 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 klient otrzymał przydatne informacje o błędach, zwracaj błędy z elementu wywoływanego przez wywołanie (lub zwracanie obietnicy odrzuconej z użyciem) instancji functions.https.HttpsError. Błąd zawiera atrybut code, który może być jedną z wartości wymienionych w functions.https.HttpsError. Błędy zawierają też ciąg znaków message, który domyślnie jest pusty. Mogą też zawierać opcjonalne pole details z dowolną wartością. Jeśli funkcje będą zgłosić błąd inny niż HttpsError, klient 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, które zwracają 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 ukończoną funkcję wywoływaną w index.js, zostanie ona wdrożona wraz ze wszystkimi innymi funkcjami po uruchomieniu firebase deploy. Aby wdrożyć tylko wywołania, które można wywołać, użyj argumentu --only w sposób pokazany podczas wykonywania częściowych wdrożeń:

firebase deploy --only functions:addMessage

Jeśli podczas wdrażania funkcji wystąpią błędy uprawnień, upewnij się, że do użytkownika wykonującego polecenia wdrożenia są przypisane odpowiednie role uprawnień.

Konfigurowanie środowiska programistycznego klienta

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

iOS lub nowszy

Wykonaj instrukcje dodawania Firebase do aplikacji Apple.

Do instalowania zależności Firebase i zarządzania nimi używaj menedżera pakietów Swift.

  1. Po otwarciu projektu aplikacji w Xcode przejdź do File > Add Packages (Plik > Dodaj pakiety).
  2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK platformy Apple dla platform 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. Gdy skończysz, Xcode zacznie automatycznie rozpoznawać i pobierać zależności w tle.

Web modular API

  1. Wykonaj instrukcje dodawania Firebase do aplikacji internetowej. Pamiętaj, aby uruchomić to polecenie w terminalu:
    npm install firebase@10.12.1 --save
    
  2. Ręcznie musisz wymagać 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);
    

Interfejs API Web Namespaced

  1. Wykonaj instrukcje dodawania Firebase do aplikacji internetowej.
  2. Dodaj do aplikacji podstawowe biblioteki Firebase i biblioteki klienta 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 w pakiecie npm.

  1. Uruchom to polecenie w terminalu:
    npm install firebase@8.10.1 --save
    
  2. Ręcznie musisz 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 instrukcje dodawania Firebase do aplikacji na Androida.

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

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

    Dzięki wykorzystaniu BM od Firebase Android Twoja aplikacja zawsze będzie używała zgodnych wersji bibliotek Firebase na Androida.

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

    Jeśli nie chcesz używać BoM Firebase, 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 biblioteki. Zapewni to 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.0.0")
    }
    
    Szukasz modułu biblioteki dotyczącego konkretnego narzędzia Kotlin? Od października 2023 r. (Firebase BoM w wersji 32.5.0) deweloperzy korzystający z Kotlin i Javy mogą korzystać z modułu biblioteki głównej (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania na temat tej inicjatywy).

Java

  1. Wykonaj instrukcje dodawania Firebase do aplikacji na Androida.

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

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

    Dzięki wykorzystaniu BM od Firebase Android Twoja aplikacja zawsze będzie używała zgodnych wersji bibliotek Firebase na Androida.

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

    Jeśli nie chcesz używać BoM Firebase, 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 biblioteki. Zapewni to 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.0.0")
    }
    
    Szukasz modułu biblioteki dotyczącego konkretnego narzędzia Kotlin? Od października 2023 r. (Firebase BoM w wersji 32.5.0) deweloperzy korzystający z Kotlin i Javy mogą korzystać z modułu biblioteki głównej (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania na temat tej inicjatywy).

Dart

  1. Wykonaj instrukcje dodawania Firebase do aplikacji Flutter.

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

    flutter pub add cloud_functions
    
  3. Gdy skończysz, ponownie skompiluj aplikację Flutter:

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

    import 'package:cloud_functions/cloud_functions.dart';
    

C++

W C++ na Androidzie:

  1. Wykonaj instrukcje dodawania Firebase do projektu C++.
  2. Dodaj bibliotekę firebase_functions do pliku CMakeLists.txt.

W przypadku C++ na platformy Apple:

  1. Wykonaj instrukcje dodawania Firebase do projektu C++.
  2. Dodaj pod Cloud Functions do Podfile:
    pod 'Firebase/Functions'
  3. Zapisz plik, a następnie uruchom polecenie:
    pod install
  4. Dodaj do projektu Xcode podstawowe elementy Firebase i platformy Cloud Functions z pakietu SDK Firebase C++ w Firebase.
    • firebase.framework
    • firebase_functions.framework

Unity

  1. Wykonaj instrukcje dodawania Firebase do projektu Unity.
  2. Dodaj FirebaseFunctions.unitypackage z pakietu SDK Firebase Unity do projektu Unity.

Inicjowanie pakietu SDK klienta

Zainicjuj instancję funkcji w Cloud Functions:

Swift

lazy var functions = Functions.functions()

Objective-C

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

Interfejs API Web Namespaced

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 modular API

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łanie 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
  }
}

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"];
}];

Interfejs API Web Namespaced

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

Web modular API

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 na kliencie

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

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

Interfejs API Web Namespaced

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 modular API

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

Zanim uruchomisz aplikację, włącz Sprawdzanie aplikacji, aby mieć pewność, że tylko aplikacje będą miały dostęp do punktów końcowych funkcji możliwych do wywołania.