Configurar varios proyectos

Esta página describe cómo usar más de un proyecto de Firebase en su aplicación.

Muchas aplicaciones solo necesitan un único proyecto de Firebase y la configuración predeterminada que se describe en las guías de introducción . Algunos ejemplos de cuándo puede resultar útil utilizar varios proyectos de Firebase son:

• Configurar su entorno de desarrollo para usar diferentes proyectos de Firebase según el tipo de compilación o el objetivo.
• Acceder al contenido de múltiples proyectos de Firebase en su aplicación.

Admite diferentes entornos

Un caso de uso común es admitir proyectos de Firebase separados para sus entornos de desarrollo y producción.

Los SDK web y de administración se configuran pasando valores directamente a sus funciones de inicialización. Para estos SDK, puede utilizar una verificación de tiempo de ejecución para seleccionar variables de configuración de desarrollo o producción.

Las plataformas Android y Apple (y sus contenedores Unity y C++) normalmente cargan la configuración desde un archivo de configuración: GoogleService-Info.plist en la plataforma Apple y google-services.json en Android. Estos archivos se leen en un objeto de opciones ( FIROption o FirebaseOptions ) al que hace referencia el objeto de la aplicación Firebase ( FIRApp o FirebaseApp ).

Para estas plataformas, el cambio entre entornos generalmente se implementa como una decisión en el momento de la compilación, mediante el uso de diferentes archivos de configuración para cada entorno.

Admite múltiples entornos en tu aplicación Apple

De forma predeterminada, FirebaseApp.configure() cargará el archivo GoogleService-Info.plist incluido con la aplicación. Si sus entornos de desarrollo y producción están configurados como objetivos separados en Xcode, puede:

• Descargue ambos archivos GoogleService-Info.plist
• Almacene los dos archivos en directorios diferentes
• Agrega ambos a tu proyecto Xcode
• Asocie los diferentes archivos con los diferentes destinos utilizando el panel Membresía de destino:

Si las compilaciones son parte de un único objetivo, la mejor opción es dar a ambos archivos de configuración nombres únicos (por ejemplo, GoogleService-Info-Free.plist y GoogleService-Info-Paid.plist ). Luego elija en tiempo de ejecución qué plist cargar. Esto se muestra en el siguiente ejemplo:

// Load a named file.
let filePath = Bundle.main.path(forResource: "MyGoogleService", ofType: "plist")
guard let fileopts = FirebaseOptions(contentsOfFile: filePath!)
  else { assert(false, "Couldn't load config file") }
FirebaseApp.configure(options: fileopts)

Admite múltiples entornos en tu aplicación de Android

En Android, el complemento Gradle de Servicios de Google procesa el archivo google-services.json en recursos de cadena de Android. Puede ver qué recursos se crean en la documentación del complemento de servicios de Google sobre Procesamiento del archivo JSON .

Puede tener varios archivos google-services.json para diferentes variantes de compilación colocando los archivos google-services.json en directorios dedicados nombrados para cada variante en la raíz del módulo de la aplicación. Por ejemplo, si tiene versiones de compilación de "desarrollo" y "lanzamiento", su configuración podría organizarse de esta manera:

app/
    google-services.json
    src/development/google-services.json
    src/release/google-services.json
    ...

Para obtener más información, consulte la documentación del complemento de servicios de Google sobre cómo agregar el archivo JSON .

Luego, FirebaseInitProvider carga estos recursos, que se ejecuta antes del código de su aplicación e inicializa las API de Firebase usando esos valores.

Debido a que este proveedor solo lee recursos con nombres conocidos, otra opción es agregar los recursos de cadena directamente a su aplicación en lugar de usar el complemento Gradle de Servicios de Google. Puedes hacer esto mediante:

• Eliminando el complemento google-services de su build.gradle raíz
• Eliminar google-services.json de su proyecto
• Agregar los recursos de cadena directamente
• Eliminando apply plugin: 'com.google.gms.google-services' de su aplicación build.gradle

Utilice múltiples proyectos en su aplicación

A veces es necesario acceder a diferentes proyectos utilizando las mismas API; por ejemplo, acceder a varias instancias de bases de datos. En la mayoría de los casos, existe un objeto de aplicación de Firebase central que administra la configuración de todas las API de Firebase. Este objeto se inicializa como parte de su configuración normal. Sin embargo, cuando desee acceder a varios proyectos desde una sola aplicación, necesitará un objeto de aplicación de Firebase distinto para hacer referencia a cada uno de ellos individualmente. Depende de usted inicializar estas otras instancias.

En ambos casos, primero debe crear un objeto de opciones de Firebase para contener los datos de configuración de la aplicación Firebase. La documentación completa de las opciones se puede encontrar en la documentación de referencia de API para las siguientes clases:

• Swift: FirebaseOptions(googleAppID:gcmSenderID:)
• Android: FirebaseOptions.Builder
• Web: initializeApp()
• C++: firebase::App::Create
• Unidad: FirebaseApp.Create
• Node.js: initializeApp
• Java: FirebaseOptions.Builder

El uso de estas clases para admitir múltiples proyectos en una aplicación se muestra en los siguientes ejemplos:

// Configure with manual options. Note that projectID and apiKey, though not
// required by the initializer, are mandatory.
let secondaryOptions = FirebaseOptions(googleAppID: "1:27992087142:ios:2a4732a34787067a",
                                       gcmSenderID: "27992087142")
secondaryOptions.apiKey = "AIzaSyBicqfAZPvMgC7NZkjayUEsrepxuXzZDsk"
secondaryOptions.projectID = "projectid-12345"

// The other options are not mandatory, but may be required
// for specific Firebase products.
secondaryOptions.bundleID = "com.google.firebase.devrel.FiroptionConfiguration"
secondaryOptions.trackingID = "UA-12345678-1"
secondaryOptions.clientID = "27992087142-ola6qe637ulk8780vl8mo5vogegkm23n.apps.googleusercontent.com"
secondaryOptions.databaseURL = "https://myproject.firebaseio.com"
secondaryOptions.storageBucket = "myproject.appspot.com"
secondaryOptions.androidClientID = "12345.apps.googleusercontent.com"
secondaryOptions.deepLinkURLScheme = "myapp://"
secondaryOptions.storageBucket = "projectid-12345.appspot.com"
secondaryOptions.appGroupID = nil
AppDelegate.swift

// Manually configure Firebase Options. The following fields are REQUIRED:
//   - Project ID
//   - App ID
//   - API Key
val options = FirebaseOptions.Builder()
    .setProjectId("my-firebase-project")
    .setApplicationId("1:27992087142:android:ce3b6448250083d1")
    .setApiKey("AIzaSyADUe90ULnQDuGShD9W23RDP0xmeDc6Mvw")
    // .setDatabaseUrl(...)
    // .setStorageBucket(...)
    .build()
MainActivity.kt

// Manually configure Firebase Options. The following fields are REQUIRED:
//   - Project ID
//   - App ID
//   - API Key
FirebaseOptions options = new FirebaseOptions.Builder()
        .setProjectId("my-firebase-project")
        .setApplicationId("1:27992087142:android:ce3b6448250083d1")
        .setApiKey("AIzaSyADUe90ULnQDuGShD9W23RDP0xmeDc6Mvw")
        // setDatabaseURL(...)
        // setStorageBucket(...)
        .build();
MainActivity.java

// The following fields are REQUIRED:
//  - Project ID
//  - App ID
//  - API Key
const secondaryAppConfig = {
    projectId: "<PROJECT_ID>",
    appId: "<APP_ID>",
    apiKey: "<API_KEY>",
    // databaseURL: "...",
    // storageBucket: "...",
};
firebaseapp.js

firebase::AppOptions secondary_app_options;

// API key, app ID, and project ID are always required.
secondary_app_options.set_api_key("<API_KEY>");
secondary_app_options.set_app_id("<GOOGLE_APP_ID>");
secondary_app_options.set_project_id("<PROJECT_ID>");

// The following options are specific to individual Firebase products
// and may not always be required.
secondary_app_options.set_database_url("<DATABASE_URL>");
secondary_app_options.set_messaging_sender_id("<SENDER_ID>");
secondary_app_options.set_storage_bucket("<STORAGE_BUCKET>");

Firebase.AppOptions secondaryAppOptions = new Firebase.AppOptions {
  ApiKey = "<API_KEY>",
  AppId = "<GOOGLE_APP_ID>",
  ProjectId = "<PROJECT_ID>"
};

const secondaryServiceAccount = require('./path/to/serviceAccountKey.json');

// All required options are specified by the service account,
// add service-specific configuration like databaseURL as needed.
const secondaryAppConfig = {
    credential: cert(secondaryServiceAccount),
    // databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
};
index.js

FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountKey.json");

FirebaseOptions secondaryAppConfig = new FirebaseOptions.Builder()
  .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
  .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
  .build();

Después de haber inicializado este objeto de opciones, puede usarlo para configurar una instancia de aplicación Firebase adicional. Tenga en cuenta que en todos los ejemplos que se muestran a continuación utilizamos la cadena secundaria . Este nombre se utiliza para recuperar la instancia de la aplicación y para distinguirla de otras instancias, incluida la instancia predeterminada (llamada [DEFAULT] ). Debes elegir una cadena apropiada para el uso previsto del otro proyecto de Firebase.

Los siguientes fragmentos demuestran la conexión a una base de datos en tiempo real alternativa (las API para otras funciones de Firebase siguen el mismo patrón).

// Configure an alternative FIRApp.
FirebaseApp.configure(name: "secondary", options: secondaryOptions)

// Retrieve a previous created named app.
guard let secondary = FirebaseApp.app(name: "secondary")
  else { assert(false, "Could not retrieve secondary app") }


// Retrieve a Real Time Database client configured against a specific app.
let secondaryDb = Database.database(app: secondary)
AppDelegate.swift

// Initialize secondary FirebaseApp.
Firebase.initialize(context = this, options, "secondary")

// Retrieve secondary FirebaseApp.
val secondary = Firebase.app("secondary")
// Get the database for the other app.
val secondaryDatabase = Firebase.database(secondary)
MainActivity.kt

// Initialize with secondary app
FirebaseApp.initializeApp(this /* Context */, options, "secondary");

// Retrieve secondary FirebaseApp
FirebaseApp secondary = FirebaseApp.getInstance("secondary");
MainActivity.java

// Initialize another app with a different config
const secondaryApp = firebase.initializeApp(secondaryAppConfig, "secondary");
// Access services, such as the Realtime Database
// secondaryApp.database();
firebaseapp.js

firebase::App* secondary_app = firebase::App::Create(secondary_app_options, "Secondary");
firebase::database::Database* secondary_database = firebase::database::Database::GetInstance(secondary_app);

var secondaryApp = Firebase.FirebaseApp.Create(secondaryAppOptions, "Secondary"));
var secondaryDatabase = Firebase.Database.FirebaseDatabase.getInstance(secondaryApp);

// Initialize another app with a different config
const secondary = initializeApp(secondaryAppConfig, 'secondary');
// Access services, such as the Realtime Database
// const secondaryDatabase = secondary.database();
index.js

// Initialize another app with a different config
FirebaseApp secondaryApp = FirebaseApp.initializeApp(secondaryAppConfig, "secondary");

// Retrieve the database.
FirebaseDatabase secondaryDatabase = FirebaseDatabase.getInstance(secondaryApp);

Garantice informes confiables para Analytics

Google Analytics recopila eventos muy temprano en el flujo de inicio de la aplicación, en algunas ocasiones antes de que se haya configurado la instancia principal de la aplicación Firebase. En estos casos, Firebase hace referencia al recurso de Android o GoogleService-Info.plist en las plataformas Apple para buscar el ID correcto de la aplicación de Google para almacenar eventos. Por este motivo, recomendamos utilizar los métodos de configuración predeterminados siempre que sea posible.

Si se requiere la configuración del tiempo de ejecución, tenga en cuenta las siguientes advertencias:

1. Si utiliza AdMob y solicita anuncios al inicio como se recomienda, es posible que se pierdan algunos datos de Analytics relacionados con los anuncios móviles cuando no utilice el enfoque de configuración basado en recursos.
2. Proporcione únicamente un único ID de aplicación de Google en cada variante distribuida de su aplicación. Por ejemplo, si envía la versión 1 de su aplicación con un determinado GOOGLE_APP_ID en la configuración y luego carga la versión 2 con una ID diferente, es posible que se eliminen los datos analíticos.
3. En las plataformas Apple, no agregue GoogleService-Info.plist a su proyecto si proporciona una configuración diferente en tiempo de ejecución, ya que esto puede resultar en un cambio aparente de GOOGLE_APP_ID y provocar la pérdida de Analytics.