Llama a funciones desde tu app

Los SDK de cliente de Cloud Functions para Firebase te permiten llamar a funciones directamente desde una app de Firebase. Para hacerlo, escribe una función HTTPS que admita llamadas en Cloud Functions, ejecútala y agrega lógica de cliente para llamar a la función desde tu app.

Las funciones que admiten llamadas son similares a otras funciones HTTP, pero además tienen estas características:

Con las funciones que admiten llamadas, los tokens de Firebase Authentication y FCM se incluyen en las solicitudes automáticamente cuando están disponibles.
El activador functions.https.onCall deserializa automáticamente el cuerpo de la solicitud y valida los tokens de autenticación.

El SDK de Firebase para Cloud Functions v0.9.1 (y versiones posteriores) funciona en conjunto con estas versiones mínimas del SDK cliente de Firebase para ser compatible con las funciones HTTPS que admiten llamadas:

SDK de Firebase para iOS 5.18.2
SDK de Firebase para Android 16.3.0
SDK de Firebase JavaScript 5.9.0

Si quieres agregar una función similar a una app compilada en una plataforma no compatible, consulta la Especificación del protocolo de https.onCall. En el resto de esta guía, se proporcionan instrucciones sobre cómo escribir, implementar y llamar una función HTTPS que admite llamadas para iOS, Android, Web, C++ y Unity.

Escribe y también implementa la función que admite llamadas

Usa functions.https.onCall para crear una función HTTPS que admite llamadas. Este método recibe dos parámetros: data y context (opcional):

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

En el caso de una función que admite llamadas y guarda un mensaje de texto en Realtime Database, por ejemplo, data podría contener el texto del mensaje, mientras que los parámetros de context representan la información de autenticación del usuario:

// 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;index.js

La distancia entre la ubicación de la función que admite llamadas y la ubicación del cliente que emite la llamada puede crear una latencia de red importante. Para optimizar el rendimiento, especifica la ubicación de la función cuando corresponda. Además, asegúrate de alinear la ubicación de la función que admite llamadas con la ubicación establecida cuando inicialices el SDK en el cliente.

Cómo devolver los resultados

Para devolver los datos al cliente, muestra los datos que pueden tener codificación JSON. Por ejemplo, para mostrar el resultado de una operación de suma:

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

Para mostrar los datos después de una operación asíncrona, muestra una promesa. Los datos que muestra la promesa se devuelven al cliente. Por ejemplo, podrías mostrar el texto depurado que la función que admite llamadas escribió en Realtime Database:

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

Administra errores:

Para garantizar que el cliente obtenga información útil sobre los errores, muéstralos desde una función que acepte llamadas. Para ello, arroja una instancia de functions.https.HttpsError. El error tiene un atributo code que puede ser uno de los valores que se muestran en functions.https.HttpsError. Los errores también tienen una string message, que está vacía en su configuración predeterminada. También pueden tener un campo details opcional con un valor arbitrario. Si se arroja un error diferente de HttpsError desde tus funciones, entonces el cliente recibirá un error con el mensaje INTERNAL y el código internal.

Por ejemplo, una función podría arrojar errores de autenticación y validación de datos con mensajes de error que se devuelven al cliente que emite la llamada:

// 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.');
}index.js

Implementa la función que admite llamadas

Después de completar la función que admite llamadas dentro de index.js, se implementa junto con todas las otras funciones cuando ejecutas firebase deploy. A fin de implementar solo la función que admite llamadas, usa el argumento --only para ejecutar implementaciones parciales, como se muestra a continuación:

$ firebase deploy --only functions:addMessage

Configura el entorno de programación de tu cliente

Asegúrate de cumplir todos los requisitos y de agregar las dependencias y las bibliotecas cliente necesarias a tu app.

iOS

Sigue las instrucciones a fin de agregar Firebase a tu app para iOS.
Agrega los pods de Cloud Functions a tu Podfile
```
pod 'Firebase/Core'
```
```
pod 'Firebase/Functions'
```
Guarda el archivo y ejecuta pod install.

Web

Sigue las instrucciones para agregar Firebase a tu app web.

Agrega las bibliotecas cliente de Firebase y Cloud Functions a tu app:

<script src="https://www.gstatic.com/firebasejs/5.9.0/firebase.js"></script>
<script src="https://www.gstatic.com/firebasejs/5.9.0/firebase-functions.js"></script>

El SDK de Cloud Functions también está disponible como un paquete npm.

npm install firebase@5.8.4 --save

Deberás solicitar de forma manual Firebase y Cloud Functions.

const firebase = require("firebase");
// Required for side-effects
require("firebase/functions");

Android

Sigue las instrucciones a fin de agregar Firebase a tu app para Android.
Agrega la biblioteca para Android de Cloud Functions a tu archivo app/build.gradle:
```
implementation 'com.google.firebase:firebase-functions:16.3.0'
```

C++

Para C++ con Android:

Sigue las instrucciones para agregar Firebase a tu proyecto de C++.
Agrega la biblioteca para Android de Cloud Functions a tu archivo app/build.gradle:
```
implementation 'com.google.firebase:firebase-functions:16.3.0'
```
Vincula las bibliotecas estáticas libfirebase_app.a y libfirebase_functions.a desde el SDK de C++.

Para C++ con iOS:

Sigue las instrucciones para agregar Firebase a tu proyecto de C++.
Agrega los pods de Cloud Functions a tu Podfile
```
pod 'Firebase/Core'
```
```
pod 'Firebase/Functions'
```
Guarda el archivo y ejecuta pod install.
Agrega firebase.framework y firebase_functions.framework a tu proyecto de Xcode desde el SDK de C++.

Unity

Descarga el SDK de Firebase Unity.
Sigue las instrucciones para agregar Firebase a tu proyecto de Unity.
Selecciona el elemento de menú Assets > Import Package > Custom Package.
Importa el paquete FirebaseFunctions.unitypackage desde el SDK de Firebase Unity que descargaste.
Cuando aparezca la ventana Import Unity Package, haz clic en el botón Import.

Inicializa el SDK cliente

Inicializa una instancia de 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();

Java
Android

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

Kotlin
Android

private lateinit var functions: FirebaseFunctions
// ...
functions = FirebaseFunctions.getInstance()MainActivity.kt

C++

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

Unity

functions = Firebase.Functions.DefaultInstance;

Llama a la función

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 text = (result?.data as? [String: Any])?["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 == FIRFunctionsErrorDomain) {
      FIRFunctionsErrorCode code = error.code;
      NSString *message = error.localizedDescription;
      NSObject *details = error.userInfo[FIRFunctionsErrorDetailsKey];
    }
    // ...
  }
  self->_resultField.text = result.data[@"text"];
}];

Web

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

Java
Android

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

Kotlin
Android

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

C++

firebase::Future<firebase::functions::HttpsCallableResult> AddMessage(
    const 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;
  });
}

Administra errores en el cliente

El cliente recibe un error si el servidor arrojó un error o si se rechazó la promesa que se genera como resultado.

Si el error que muestra la función es del tipo function.https.HttpsError, el cliente recibe los valores code, message y details del error del servidor. En el caso contrario, el error contiene el mensaje INTERNAL y el código INTERNAL. Consulta la guía sobre cómo solucionar errores en tu función que admite llamadas.

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 == FIRFunctionsErrorDomain) {
    FIRFunctionsErrorCode code = error.code;
    NSString *message = error.localizedDescription;
    NSObject *details = error.userInfo[FIRFunctionsErrorDetailsKey];
  }
  // ...
}CloudAddCell.m

Web

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

Java
Android

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

Kotlin
Android

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

                // ...
            }

            // ...
        })MainActivity.kt

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

Llama a funciones desde tu app

Escribe y también implementa la función que admite llamadas

Cómo devolver los resultados

Administra errores:

Implementa la función que admite llamadas

Configura el entorno de programación de tu cliente

iOS

Web

Android

C++

Unity

Inicializa el SDK cliente

Swift

Objective-C

Web

JavaAndroid

KotlinAndroid

C++

Unity

Llama a la función

Swift

Objective-C

Web

JavaAndroid

KotlinAndroid

C++

Unity

Administra errores en el cliente

Swift

Objective-C

Web

JavaAndroid

KotlinAndroid

C++

Unity

Enviar comentarios sobre…

Java
Android

Kotlin
Android

Java
Android

Kotlin
Android

Java
Android

Kotlin
Android