Configurer plusieurs projets

Cette page décrit comment utiliser plusieurs projets Firebase dans votre application.

De nombreuses applications n'ont besoin que d'un seul projet Firebase et de la configuration par défaut décrite dans les guides de démarrage . Voici des exemples de cas où il peut être utile d'utiliser plusieurs projets Firebase :

• Configuration de votre environnement de développement pour utiliser différents projets Firebase en fonction du type de build ou de la cible.
• Accéder au contenu de plusieurs projets Firebase dans votre application.

Prise en charge de différents environnements

Un cas d'utilisation courant consiste à prendre en charge des projets Firebase distincts pour vos environnements de développement et de production.

Les SDK Web et d'administration sont configurés en transmettant directement des valeurs à leurs fonctions d'initialisation. Pour ces SDK, vous pouvez utiliser une vérification d'exécution pour sélectionner les variables de configuration de développement ou de production.

Les plates-formes Android et Apple (et leurs wrappers Unity et C++) chargent normalement la configuration à partir d'un fichier de configuration : GoogleService-Info.plist sur la plate-forme Apple et google-services.json sur Android. Ces fichiers sont lus dans un objet d'options ( FIROption ou FirebaseOptions ) qui est référencé par l'objet d'application Firebase ( FIRApp ou FirebaseApp ).

Pour ces plates-formes, le basculement entre les environnements est généralement mis en œuvre en tant que décision au moment de la génération, via l'utilisation de différents fichiers de configuration pour chaque environnement.

Prise en charge de plusieurs environnements dans votre application Apple

Par défaut, FirebaseApp.configure() chargera le fichier GoogleService-Info.plist fourni avec l'application. Si vos environnements de développement et de production sont configurés en tant que cibles distinctes dans Xcode, vous pouvez :

• Téléchargez les deux fichiers GoogleService-Info.plist
• Stockez les deux fichiers dans des répertoires différents
• Ajoutez les deux à votre projet Xcode
• Associez les différents fichiers aux différentes cibles à l'aide du panneau Target Membership :

Si les builds font partie d'une seule cible, la meilleure option est de donner aux deux fichiers de configuration des noms uniques (par exemple GoogleService-Info-Free.plist et GoogleService-Info-Paid.plist ). Choisissez ensuite au moment de l'exécution quel plist charger. Ceci est illustré dans l'exemple suivant :

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

Avertissement : Cette approche peut avoir un impact sur la collecte d'analyses dans certaines circonstances, voir la section sur les analyses fiables .

Prend en charge plusieurs environnements dans votre application Android

Dans Android, le fichier google-service.json est traité en ressources de chaîne Android par le plug-in Google Services Gradle. Vous pouvez voir quelles ressources sont créées dans la documentation de Google Services Plugin sur Processing the JSON file .

Vous pouvez avoir plusieurs fichiers google-services.json pour différentes variantes de construction en plaçant les fichiers google-services.json dans des répertoires dédiés nommés pour chaque variante sous la racine du module d'application. Par exemple, si vous avez des variantes de build "development" et "release", votre configuration pourrait être organisée comme ceci :

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

Pour en savoir plus, consultez la documentation du plug-in Google Services sur l'ajout du fichier JSON .

Ces ressources sont ensuite chargées par le FirebaseInitProvider , qui s'exécute avant le code de votre application et initialise les API Firebase à l'aide de ces valeurs.

Étant donné que ce fournisseur ne fait que lire des ressources avec des noms connus, une autre option consiste à ajouter les ressources de chaîne directement à votre application au lieu d'utiliser le plug-in Google Services Gradle. Vous pouvez le faire en :

• Suppression du plugin google-services de votre racine build.gradle
• Suppression de google-services.json de votre projet
• Ajout direct des ressources de chaîne
• Suppression apply plugin: 'com.google.gms.google-services' de votre application build.gradle

Utilisez plusieurs projets dans votre application

Parfois, vous devez accéder à différents projets à l'aide des mêmes API, par exemple en accédant à plusieurs instances de base de données. Dans la plupart des cas, il existe un objet d'application Firebase central qui gère la configuration de toutes les API Firebase. Cet objet est initialisé dans le cadre de votre configuration normale. Cependant, lorsque vous souhaitez accéder à plusieurs projets à partir d'une seule application, vous aurez besoin d'un objet d'application Firebase distinct pour référencer chacun individuellement. C'est à vous d'initialiser ces autres instances.

Dans les deux cas, vous devez d'abord créer un objet d'options Firebase pour contenir les données de configuration de l'application Firebase. La documentation complète des options se trouve dans la documentation de référence de l'API pour les classes suivantes :

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

L'utilisation de ces classes pour prendre en charge plusieurs projets dans une application est illustrée dans les exemples suivants :

Rapide

// 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

Kotlin+KTX

// 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

Java

// 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

la toile

// 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

C++

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

Unité

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

Node.js

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

Java

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

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

Après avoir initialisé cet objet d'options, vous pouvez l'utiliser pour configurer une instance d'application Firebase supplémentaire. Notez que dans tous les exemples ci-dessous, nous utilisons la chaîne secondaire . Ce nom est utilisé pour récupérer l'instance de l'application et pour la distinguer des autres instances, y compris l'instance par défaut (nommée [DEFAULT] ). Vous devez choisir une chaîne appropriée à l'utilisation prévue de l'autre projet Firebase.

Les extraits suivants illustrent la connexion à une autre base de données en temps réel (les API des autres fonctionnalités de Firebase suivent le même modèle).

Rapide

// 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

Kotlin+KTX

// 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

Java

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

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

la toile

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

C++

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

Unité

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

Node.js

// 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

Java

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

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

Remarque : sur les plates-formes Android et Apple, Analytics n'est enregistré que pour l'application par défaut.

Assurer des rapports fiables pour Analytics

Google Analytics collecte les événements très tôt dans le flux de démarrage de l'application, dans certains cas avant que l'instance principale de l'application Firebase ait été configurée. Dans ces cas, Firebase fait référence à la ressource Android ou GoogleService-Info.plist sur les plates-formes Apple pour rechercher l'ID d'application Google correct pour stocker les événements. Pour cette raison, nous vous recommandons d'utiliser les méthodes de configuration par défaut dans la mesure du possible.

Si une configuration d'exécution est requise, veuillez noter les mises en garde suivantes :

1. Si vous utilisez AdMob et que vous demandez des annonces au démarrage comme recommandé, vous risquez de manquer certaines données Analytics liées aux annonces pour mobile lorsque vous n'utilisez pas l'approche de configuration basée sur les ressources.
2. Ne fournissez jamais qu'un seul ID d'application Google dans chaque variante distribuée de votre application. Par exemple, si vous livrez la version 1 de votre application avec un certain GOOGLE_APP_ID dans la configuration, puis téléchargez la version 2 avec un ID différent, cela peut entraîner la suppression des données d'analyse.
3. Sur les plates-formes Apple, n'ajoutez pas GoogleService-Info.plist à votre projet si vous fournissez une configuration différente au moment de l'exécution, car cela peut entraîner une modification apparente de GOOGLE_APP_ID et entraîner la perte d'Analytics.