Pakiety SDK klienta Cloud Functions for Firebase umożliwiają wywoływanie funkcji bezpośrednio z aplikacji Firebase. Aby w ten sposób wywołać funkcję z aplikacji, napisz i wdróż funkcję HTTP Callable w Cloud Functions, a następnie dodaj logikę klienta, aby wywołać funkcję z aplikacji.
Należy pamiętać, że wywoływalne funkcje HTTP są podobne, ale nie identyczne z funkcjami HTTP. Aby korzystać z wywoływalnych funkcji HTTP, musisz użyć pakietu SDK klienta dla swojej platformy wraz z interfejsem API zaplecza (lub zaimplementować protokół). Wywoływalne mają następujące kluczowe różnice w stosunku do funkcji HTTP:
Wywoływalne mają następujące kluczowe różnice w stosunku do funkcji HTTP:
- W przypadku wywołań tokeny uwierzytelniania Firebase, tokeny FCM i tokeny sprawdzania aplikacji, jeśli są dostępne, są automatycznie uwzględniane w żądaniach.
- Wyzwalacz automatycznie deserializuje treść żądania i sprawdza poprawność tokenów uwierzytelniania.
Pakiet Firebase SDK for Cloud Functions 2. generacji lub nowszy współpracuje z tymi minimalnymi wersjami pakietu SDK klienta Firebase, aby obsługiwać funkcje wywoływane przez HTTPS:
- Firebase SDK dla platform Apple 10.10.0
- Firebase SDK dla Androida 20.3.1
- Firebase Modular Web SDK w wersji 9.7.0
Jeśli chcesz dodać podobną funkcjonalność do aplikacji zbudowanej na nieobsługiwanej platformie, zapoznaj się ze specyfikacją protokołu dla https.onCall
. Pozostała część tego przewodnika zawiera instrukcje dotyczące pisania, wdrażania i wywoływania funkcji wywoływanej przez HTTP dla platform firmy Apple, systemu Android, sieci Web, języka C++ i aparatu Unity.
Napisz i wdróż funkcję wywoływalną
Użyj functions.https.onCall
, aby utworzyć funkcję wywoływalną przez HTTPS. Ta metoda przyjmuje dwa 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) => {
// ...
});
Na przykład w przypadku wywoływanej funkcji, która zapisuje wiadomość tekstową w bazie danych czasu rzeczywistego, data
mogą zawierać tekst wiadomości, podczas gdy parametry context
reprezentują informacje o autoryzacji użytkownika:
// Message text passed from the client.
const text = data.text;
// Authentication / user information is automatically added to the request.
const uid = context.auth.uid;
const name = context.auth.token.name || null;
const picture = context.auth.token.picture || null;
const email = context.auth.token.email || null;
Odległość między lokalizacją funkcji możliwej do wywołania a lokalizacją klienta wywołującego może spowodować opóźnienie w sieci. Aby zoptymalizować wydajność, rozważ określenie lokalizacji funkcji tam, gdzie ma to zastosowanie, i upewnij się, że lokalizacja wywoływania jest wyrównana z lokalizacją ustawioną podczas inicjowania zestawu SDK po stronie klienta.
Opcjonalnie możesz dołączyć zaświadczenie kontroli aplikacji, aby chronić zasoby zaplecza przed nadużyciami, takimi jak oszustwa związane z rozliczeniami lub wyłudzanie informacji. Zobacz Włączanie wymuszania sprawdzania aplikacji dla Cloud Functions .
Odesłanie wyniku
Aby wysłać dane z powrotem do klienta, zwróć dane, które można zakodować w formacie JSON. Na przykład, aby 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 przez promesę są odsyłane z powrotem do klienta. Na przykład możesz zwrócić oczyszczony tekst, który funkcja wywoływalna zapisała w bazie danych czasu rzeczywistego:
// Saving the new message to the Realtime Database.
const sanitizedMessage = sanitizer.sanitizeText(text); // Sanitize the message.
return admin.database().ref('/messages').push({
text: sanitizedMessage,
author: { uid, name, picture, email },
}).then(() => {
console.log('New Message written');
// Returning the sanitized message to the client.
return { text: sanitizedMessage };
})
Obsługuj błędy
Aby upewnić się, że klient otrzyma przydatne szczegóły błędu, zwróć błędy z elementu wywoływalnego, rzucając (lub zwracając obietnicę odrzuconą z) instancją functions.https.HttpsError
. Błąd ma atrybut code
, który może być jedną z wartości wymienionych w functions.https.HttpsError
. Błędy mają również message
tekstowy, który domyślnie jest pustym łańcuchem. Mogą również mieć opcjonalne pole details
z dowolną wartością. Jeśli z twoich funkcji zostanie zgłoszony błąd inny niż HttpsError
, twój klient zamiast tego otrzyma błąd z komunikatem INTERNAL
i kodem internal
.
Na przykład funkcja może zgłaszać błędy sprawdzania poprawności danych i uwierzytelniania z komunikatami o błędach, aby zwrócić je do wywołującego klienta:
// Checking attribute.
if (!(typeof text === 'string') || text.length === 0) {
// Throwing an HttpsError so that the client gets the error details.
throw new functions.https.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 (!context.auth) {
// Throwing an HttpsError so that the client gets the error details.
throw new functions.https.HttpsError('failed-precondition', 'The function must be called ' +
'while authenticated.');
}
Wdróż funkcję wywoływalną
Po zapisaniu ukończonej funkcji wywoływalnej w index.js
jest ona wdrażana wraz ze wszystkimi innymi funkcjami po uruchomieniu firebase deploy
. Aby wdrożyć tylko wywoływalne, użyj argumentu --only
, jak pokazano, aby wykonać częściowe wdrożenia :
firebase deploy --only functions:addMessage
Jeśli podczas wdrażania funkcji napotkasz błędy uprawnień, upewnij się, że odpowiednie role IAM są przypisane do użytkownika uruchamiającego polecenia wdrażania.
Skonfiguruj środowisko programistyczne klienta
Upewnij się, że spełniasz wszystkie wymagania wstępne, a następnie dodaj wymagane zależności i biblioteki klienckie do swojej aplikacji.
iOS+
Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji Apple .
Użyj Menedżera pakietów Swift, aby zainstalować i zarządzać zależnościami Firebase.
- W Xcode przy otwartym projekcie aplikacji przejdź do File > Add Packages .
- Po wyświetleniu monitu dodaj repozytorium Firebase Apple platforms SDK:
- Wybierz bibliotekę Cloud Functions.
- Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk
Modułowy interfejs API sieci Web
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji internetowej . Upewnij się, że uruchomiłeś następujące polecenie z terminala:
npm install firebase@9.22.1 --save
Ręcznie wymagaj 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);
Internetowy interfejs API z przestrzenią nazw
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji internetowej .
- Dodaj podstawowe biblioteki Firebase i Cloud Functions do swojej aplikacji:
<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>
Zestaw Cloud Functions SDK jest również dostępny jako pakiet npm.
- Uruchom następującą komendę ze swojego terminala:
npm install firebase@8.10.1 --save
- Ręcznie wymagaj zarówno podstawowych funkcji Firebase, jak i Cloud Functions:
const firebase = require("firebase"); // Required for side-effects require("firebase/functions");
Kotlin+KTX
Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji na Androida .
W pliku Gradle modułu (na poziomie aplikacji) (zwykle
<project>/<app-module>/build.gradle
) dodaj zależność biblioteki Cloud Functions Android. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:32.1.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-ktx' }
Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze korzystać ze zgodnych wersji bibliotek Firebase Android.
(Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z BoM
Jeśli zdecydujesz się nie używać BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.
Pamiętaj, że jeśli używasz w swojej aplikacji 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-ktx:20.3.1' }
Java
Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji na Androida .
W pliku Gradle modułu (na poziomie aplikacji) (zwykle
<project>/<app-module>/build.gradle
) dodaj zależność biblioteki Cloud Functions Android. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.dependencies { // Import the BoM for the Firebase platform implementation platform('com.google.firebase:firebase-bom:32.1.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' }
Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze korzystać ze zgodnych wersji bibliotek Firebase Android.
(Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z BoM
Jeśli zdecydujesz się nie używać BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.
Pamiętaj, że jeśli używasz w swojej aplikacji 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:20.3.1' }
Dart
Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojej aplikacji Flutter .
W katalogu głównym projektu Flutter uruchom następujące polecenie, aby zainstalować wtyczkę:
flutter pub add cloud_functions
Po zakończeniu odbuduj aplikację Flutter:
flutter run
Po zainstalowaniu możesz uzyskać dostęp do wtyczki
cloud_functions
, importując ją w swoim kodzie Dart:import 'package:cloud_functions/cloud_functions.dart';
C++
Dla C++ z Androidem :
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojego projektu C++ .
- Dodaj bibliotekę
firebase_functions
do plikuCMakeLists.txt
.
Dla C++ z platformami Apple :
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojego projektu C++ .
- Dodaj pod Cloud Functions do pliku
Podfile
:pod 'Firebase/Functions'
- Zapisz plik, a następnie uruchom:
pod install
- Dodaj podstawowe struktury Firebase i Cloud Functions z pakietu Firebase C++ SDK do swojego projektu Xcode.
-
firebase.framework
-
firebase_functions.framework
-
Jedność
- Postępuj zgodnie z instrukcjami, aby dodać Firebase do swojego projektu Unity .
- Dodaj
FirebaseFunctions.unitypackage
z pakietu Firebase Unity SDK do swojego projektu Unity.
Zainicjuj zestaw SDK klienta
Zainicjuj instancję Cloud Functions:
Szybki
lazy var functions = Functions.functions()
Cel C
@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];
Internetowy interfejs API z przestrzenią nazw
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();
Modułowy interfejs API sieci 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);
Jedność
functions = Firebase.Functions.DefaultInstance;
Wywołaj funkcję
Szybki
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
}
}
Cel 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"];
}];
Internetowy interfejs API z przestrzenią nazw
var addMessage = firebase.functions().httpsCallable('addMessage');
addMessage({ text: messageText })
.then((result) => {
// Read result of the Cloud Function.
var sanitizedMessage = result.data.text;
});
Modułowy interfejs API sieci 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);
}
Jedność
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 otrzymuje komunikat o błędzie, jeśli serwer zgłosił błąd lub wynikowa obietnica została odrzucona.
Jeśli błąd zwrócony przez funkcję jest typu function.https.HttpsError
, to klient otrzymuje code
błędu , message
i details
błędu serwera. W przeciwnym razie błąd zawiera komunikat INTERNAL
i kod INTERNAL
. Zobacz wskazówki dotyczące obsługi błędów w funkcji możliwej do wywołania.
Szybki
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]
}
// ...
}
Cel C
if (error) {
if ([error.domain isEqual:@"com.firebase.functions"]) {
FIRFunctionsErrorCode code = error.code;
NSString *message = error.localizedDescription;
NSObject *details = error.userInfo[@"details"];
}
// ...
}
Internetowy interfejs API z przestrzenią nazw
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;
// ...
});
Modułowy interfejs API sieci 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);
// ...
Jedność
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 dzięki funkcji Sprawdzanie aplikacji
Przed uruchomieniem aplikacji należy włączyć sprawdzanie aplikacji , aby mieć pewność, że tylko Twoje aplikacje będą miały dostęp do punktów końcowych funkcji, które można wywoływać.