Mehrere Projekte konfigurieren

Auf dieser Seite wird beschrieben, wie Sie mehr als ein Firebase-Projekt in Ihrer App verwenden.

Für viele Apps sind nur ein einziges Firebase-Projekt und die in den Startleitfäden beschriebene Standardeinrichtung erforderlich. Beispiele für Situationen, in denen es nützlich sein kann, mehrere Firebase-Projekte zu verwenden:

• Entwicklungsumgebung so einrichten, dass je nach Build-Typ oder Ziel unterschiedliche Firebase-Projekte verwendet werden
• Zugriff auf die Inhalte aus mehreren Firebase-Projekten in Ihrer App.

Unterstützung verschiedener Umgebungen

Ein häufiger Anwendungsfall ist die Unterstützung separater Firebase-Projekte für Ihre Entwicklungs- und Produktionsumgebungen.

Die Web- und Admin-SDKs werden konfiguriert, indem Werte direkt an ihre Initialisierungsfunktionen übergeben werden. Für diese SDKs können Sie eine Laufzeitprüfung verwenden, um Konfigurationsvariablen für die Entwicklung oder Produktion auszuwählen.

Android- und Apple-Plattformen (und ihre Unity- und C++-Wrapper) laden die Konfiguration normalerweise aus einer Konfigurationsdatei: GoogleService-Info.plist auf der Apple-Plattform und google-services.json auf Android. Diese Dateien werden in ein Optionsobjekt (FIROption oder FirebaseOptions) eingelesen, auf das das Firebase-Anwendungsobjekt (FIRApp oder FirebaseApp) verweist.

Bei diesen Plattformen wird der Wechsel zwischen Umgebungen in der Regel als Build-Zeit-Entscheidung implementiert, indem für jede Umgebung unterschiedliche Konfigurationsdateien verwendet werden.

Mehrere Umgebungen in Ihrer Apple-Anwendung unterstützen

Standardmäßig lädt FirebaseApp.configure() die Datei GoogleService-Info.plist, die mit der Anwendung gebündelt ist. Wenn Ihre Entwicklungs- und Produktionsumgebungen in Xcode als separate Ziele konfiguriert sind, können Sie Folgendes tun:

• Beide GoogleService-Info.plist-Dateien herunterladen
• Speichern Sie die beiden Dateien in verschiedenen Verzeichnissen.
• Fügen Sie beide Ihrem Xcode-Projekt hinzu.
• Verknüpfen Sie die verschiedenen Dateien mit den verschiedenen Zielen über das Steuerfeld „Target Membership“:

Wenn die Builds Teil eines einzelnen Ziels sind, ist es am besten, beiden Konfigurationsdateien eindeutige Namen zu geben (z.B. GoogleService-Info-Free.plist und GoogleService-Info-Paid.plist). Wählen Sie dann zur Laufzeit aus, welche PLIST-Datei geladen werden soll. Dies wird im folgenden Beispiel veranschaulicht:

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

Mehrere Umgebungen in Ihrer Android-App unterstützen

In Android-Projekten wird die Konfigurationsdatei google-services.json vom Gradle-Plug-in google-services in Android-String-Ressourcen verarbeitet. Informationen dazu, welche Ressourcen vom Plug-in erstellt werden, finden Sie unter So wird die JSON-Konfigurationsdatei verarbeitet.

Sie können für jede Ihrer verschiedenen Build-Varianten eine eigene google-services.json-Konfigurationsdatei verwenden. Platzieren Sie dazu jede google-services.json-Konfigurationsdatei in einem eigenen Verzeichnis, das nach der jeweiligen Variante benannt ist, unter dem Stammverzeichnis des App-Moduls. Wenn Sie beispielsweise die Build-Varianten „development“ und „release“ haben, könnte Ihre Konfiguration so organisiert sein:

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

Weitere Informationen finden Sie unter JSON-Datei hinzufügen.

Diese Ressourcen werden dann vom FirebaseInitProvider geladen, der vor dem Anwendungscode ausgeführt wird und Firebase APIs mit diesen Werten initialisiert.

Da dieser Anbieter nur Ressourcen mit bekannten Namen liest, können Sie die String-Ressourcen auch direkt Ihrer App hinzufügen, anstatt das Gradle-Plug-in google-services zu verwenden. Dazu können Sie

• Entfernen des Gradle-Plug-ins google-services aus dem Stammverzeichnis build.gradle
• Konfigurationsdatei google-services.json aus Ihrem Projekt löschen
• String-Ressourcen direkt hinzufügen
• apply plugin: 'com.google.gms.google-services' wird aus Ihrer App gelöscht build.gradle

Mehrere Projekte in Ihrer Anwendung verwenden

Manchmal müssen Sie mit denselben APIs auf verschiedene Projekte zugreifen, z. B. auf mehrere Datenbankinstanzen. In den meisten Fällen gibt es ein zentrales Firebase-Anwendungsobjekt, das die Konfiguration für alle Firebase APIs verwaltet. Dieses Objekt wird im Rahmen der normalen Einrichtung initialisiert. Wenn Sie jedoch von einer einzelnen Anwendung aus auf mehrere Projekte zugreifen möchten, benötigen Sie für jedes Projekt ein eigenes Firebase-Anwendungsobjekt. Sie müssen diese anderen Instanzen selbst initialisieren.

In beiden Fällen müssen Sie zuerst ein Firebase-Optionsobjekt erstellen, das die Konfigurationsdaten für die Firebase-Anwendung enthält. Eine vollständige Dokumentation der Optionen finden Sie in der API-Referenzdokumentation für die folgenden Klassen:

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

Die Verwendung dieser Klassen zur Unterstützung mehrerer Projekte in einer Anwendung wird in den folgenden Beispielen gezeigt:

// 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.clientID = "27992087142-ola6qe637ulk8780vl8mo5vogegkm23n.apps.googleusercontent.com"
secondaryOptions.databaseURL = "https://myproject.firebaseio.com"
secondaryOptions.storageBucket = "myproject.appspot.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();

Nachdem Sie dieses Optionsobjekt initialisiert haben, können Sie damit eine zusätzliche Firebase-Anwendungsinstanz konfigurieren. In allen unten gezeigten Beispielen wird der String secondary verwendet. Dieser Name wird verwendet, um die Anwendungsinstanz abzurufen und sie von anderen Instanzen zu unterscheiden, einschließlich der Standardinstanz (mit dem Namen [DEFAULT]). Wählen Sie einen String aus, der für die beabsichtigte Verwendung des anderen Firebase-Projekts geeignet ist.

Die folgenden Snippets zeigen, wie Sie eine Verbindung zu einer alternativen Realtime Database herstellen. Die APIs für andere Firebase-Funktionen folgen demselben Muster.

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

// Retrieve a previous created named app.
guard let secondary = FirebaseApp.app(name: "secondary")
  else { fatalError("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);

Zuverlässige Berichte für Analytics sicherstellen

Google Analytics erfasst Ereignisse sehr früh im Startablauf der App, in einigen Fällen, bevor die primäre Firebase-App-Instanz konfiguriert wurde. In diesen Fällen verweist Firebase auf die Android-Ressource oder GoogleService-Info.plist auf Apple-Plattformen, um die richtige Google-App-ID zum Speichern von Ereignissen zu finden. Daher empfehlen wir, nach Möglichkeit die Standardkonfigurationsmethoden zu verwenden.

Wenn eine Laufzeitkonfiguration erforderlich ist, beachten Sie die folgenden Einschränkungen:

1. Wenn Sie AdMob verwenden und wie empfohlen beim Start Anzeigen anfordern, fehlen Ihnen möglicherweise einige Analytics-Daten zu mobilen Anzeigen, wenn Sie nicht den ressourcenbasierten Konfigurationsansatz verwenden.
2. Geben Sie in jeder verteilten Variante Ihrer App nur eine einzige Google-App-ID an. Wenn Sie beispielsweise Version 1 Ihrer App mit einer bestimmten GOOGLE_APP_ID in der Konfiguration ausliefern und dann Version 2 mit einer anderen ID hochladen, kann dies dazu führen, dass Analysedaten verloren gehen.
3. Fügen Sie auf Apple-Plattformen die Datei „GoogleService-Info.plist“ nicht Ihrem Projekt hinzu, wenn Sie zur Laufzeit eine andere Konfiguration angeben. Dies kann zu einer scheinbaren Änderung von GOOGLE_APP_ID und zu verlorenen Analytics-Daten führen.