Configurer plusieurs projets

Cette page explique comment utiliser plusieurs projets Firebase dans votre application.

De nombreuses applications ont besoin d' un seul projet Firebase et la valeur par défaut mis en place décrites dans les guides Commencez. Voici des exemples de cas où il peut être utile d'utiliser plusieurs projets Firebase :

  • Configurer 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 Admin sont configurés en transmettant directement des valeurs à leurs fonctions d'initialisation. Pour ces SDK, vous pouvez utiliser un contrôle d'exécution pour sélectionner des variables de configuration de développement ou de production.

Et les applications iOS (et leur unité et C ++ enveloppes) charger normalement configuration à partir d' un fichier de configuration: GoogleService-Info.plist sur iOS et google-services.json sur les applications. 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 implémenté en tant que décision de temps de construction, via l'utilisation de différents fichiers de configuration pour chaque environnement.

Prise en charge de plusieurs environnements dans votre application iOS

Par défaut, FirebaseApp.configure() va charger le GoogleService-Info.plist fichier 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écharger les GoogleService-Info.plist fichiers
  • Stocker 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 :

Panneau d'adhésion cible

Si les builds font partie d'une cible unique, la meilleure option est de donner à la fois des fichiers de configuration des noms uniques (par exemple GoogleService-Info-Free.plist et GoogleService-Info-Paid.plist ). Ensuite, choisissez 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)

Prise en charge de plusieurs environnements dans votre application Android

Dans Android, le google-service.json fichier est transformé en ressources chaîne Android de Google Services de plug - in gradle. Vous pouvez voir quelles ressources sont créés dans la documentation des services Google Plugin sur le traitement du fichier JSON .

Vous pouvez avoir plusieurs google-services.json fichiers pour différents build variantes en plaçant google-services.json fichiers 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 versions 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 des services Google Plugin sur l' ajout du fichier JSON .

Ces ressources sont ensuite chargées par le FirebaseInitProvider , qui passe avant votre code d'application et les API initialise Firebase en utilisant ces valeurs.

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

  • Retrait des google-services plugin à partir de la racine de votre build.gradle
  • Suppression du 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. A 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 est disponible dans la documentation de référence de l'API pour les classes suivantes :

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

iOS

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

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

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

la toile

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

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: admin.credential.cert(secondaryServiceAccount),
    // databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
};

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 d'application, et de le distinguer d'autres cas, y compris l'instance par défaut (nommé [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).

iOS

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

Java

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

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

Kotlin+KTX

// Initialize secondary FirebaseApp.
Firebase.initialize(this /* Context */, options, "secondary")

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

la toile

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

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 = admin.initializeApp(secondaryAppConfig, 'secondary');
// Access services, such as the Realtime Database
// const secondaryDatabase = secondary.database();

Java

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

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

Garantir des rapports fiables pour Analytics

Google Analytics collecte les événements très tôt dans le flux de démarrage de l'application, parfois avant la configuration de l'instance principale de l'application Firebase. Dans ces cas, Firebase fait référence à la ressource Android ou GoogleService-Info.plist sur iOS pour rechercher l'application Google ID correct aux événements magasin. 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 qu'un seul identifiant d'application Google dans chaque variante distribuée de votre application. Par exemple, si vous expédiez version 1 de votre application avec une certaine GOOGLE_APP_ID dans la configuration puis la version télécharger 2 avec un ID différent, il peut provoquer des données d'analyse soient abandonnées.
  3. Sur iOS, ne pas ajouter GoogleService-Info.plist à votre projet si vous fournissez une configuration différente au moment de l' exécution, car cela peut entraîner un changement apparent de GOOGLE_APP_ID et entraîner Analytics perdus.