google-services.json für verschiedene productFlavors

Update: GCM ist veraltet, verwenden Sie FCM

Ich implementiere das neue Google Cloud Messaging gemäß den Anleitungen auf der Google Developers-Seite hier

Ich habe es erfolgreich ausgeführt und getestet. Mein Problem ist jetzt jedoch, dass ich unterschiedliche Produktvarianten mit unterschiedlichen Anwendungs-IDs / Paketnamen und unterschiedlichen Google Cloud Messaging-Projekt-IDs habe. Die google-services.jsonmüssen im /app/google-services.jsonnicht den Flavours-Ordner abgelegt werden .

Gibt es eine Möglichkeit, die google-services.jsonKonfiguration für viele Varianten anders zu gestalten?

Google hat die Unterstützung für Geschmacksrichtungen in Version 2.0 des Plugins für Spieledienste aufgenommen. Seit dieser Version dergradle plugin com.google.gms:google-services:2.0.0-alpha3

du kannst das

app/src/
    flavor1/google-services.json
    flavor2/google-services.json

Version 3.0.0 des Plugins sucht an diesen Speicherorten nach der JSON-Datei ( flavorvorausgesetzt, Sie haben einen Flavour1- und einen Build-Typ debug):

/app/src/debug/google-services.json
/app/src/debug/flavor1/google-services.json
/app/google-services.json

Dies funktionierte bei mir sogar mit FlavourDimensions. Ich habe kostenlos und bezahlt in einer Dimension und Mock & Prod in der anderen Dimension. Ich habe auch 3 buildTypes: Debug, Release und Staging. So sieht es in meinem Projekt für die FreeProd-Variante aus:

Wie viele google-services.json-Dateien von den Eigenschaften Ihres Projekts abhängen, Sie benötigen jedoch mindestens eine json-Datei für jedes Google-Projekt.

Wenn Sie weitere Informationen darüber wünschen, was dieses Plugin mit diesen JSON-Dateien macht, finden Sie hier: https://github.com/googlesamples/google-services/issues/54#issuecomment-165824720

Link zu den offiziellen Dokumenten: https://developers.google.com/android/guides/google-services-plugin

Blog-Beitrag mit aktualisierten Informationen: https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

Klicken Sie hier, um die neueste Version dieses Plugins zu überprüfen: https://bintray.com/android/android-tools/com.google.gms.google-services/view

UPDATE: Die folgende Erklärung bezieht sich auf ein Android Studio-Projekt mit einem Firebase-Projekt und verschiedenen Firebase-Apps in diesem Projekt. Wenn das Ziel darin besteht, unterschiedliche JSON-Dateien für unterschiedliche Firebase-Apps in unterschiedlichen Firebase-Projekten innerhalb desselben Android Studio-Projekts zu haben (oder wenn Sie nicht wissen, was der Unterschied ist), klicken Sie hier. .

Sie benötigen eine Firebase-App pro Android-Anwendungs-ID (normalerweise Paketname). Es ist üblich, eine Anwendungs-ID pro Gradle-Build-Variante zu haben (dies ist wahrscheinlich, wenn Sie Gradle-Build-Typen und Gradle-Build-Varianten verwenden).

Ab Google Services 3.0 und unter Verwendung von Firebase ist es nicht erforderlich, unterschiedliche Dateien für unterschiedliche Varianten zu erstellen. Das Erstellen verschiedener Dateien für verschiedene Geschmacksrichtungen kann nicht klar oder unkompliziert sein, wenn Sie ProductFlavours- und Build-Typen haben, die miteinander komponieren.

In derselben Datei finden Sie alle Konfigurationen, die Sie für alle Build-Typen und -Varianten benötigen.

In der Firebase-Konsole müssen Sie eine App pro Paketnamen hinzufügen. Stellen Sie sich vor, Sie haben 2 Varianten (dev und live) und 2 Build-Typen (Debug und Release). Abhängig von Ihrer Konfiguration, aber es ist wahrscheinlich, dass Sie 4 verschiedene Paketnamen haben wie:

• com.stackoverflow.example (Live - Release)
• com.stackoverflow.example.dev (live - dev)
• com.stackoverflow.example.debug (Debug - Release)
• com.stackoverflow.example.dev.debug (debug - dev)

Sie benötigen 4 verschiedene Android Apps in der Firebase-Konsole. (Auf jedem müssen Sie den SHA-1 zum Debuggen hinzufügen und für jeden Computer, den Sie verwenden, live sein.)

Wenn Sie die Datei google-services.json herunterladen, spielt es eigentlich keine Rolle, von welcher App Sie sie herunterladen. Alle enthalten dieselben Informationen zu allen Ihren Apps.

Jetzt müssen Sie diese Datei auf App-Ebene (app /) suchen.

Wenn Sie diese Datei öffnen, sehen Sie, dass sie alle Informationen für alle Ihre Paketnamen enthält.

Ein Schmerzpunkt ist das Plugin. Damit es funktioniert, müssen Sie das Plugin am Ende Ihrer Datei suchen. Also diese Zeile ..

apply plugin: 'com.google.gms.google-services'

... muss sich am Ende Ihrer App build.gradle-Datei befinden.

Für die meisten der hier genannten gilt dies auch für frühere Versionen. Ich hatte noch nie verschiedene Dateien für verschiedene Konfigurationen, aber jetzt ist die Firebase-Konsole einfacher, da sie eine einzige Datei mit allem bietet, was Sie für alle Konfigurationen benötigen.

• Firebase-Dokumente
• Firebase Cloud Messaging
• Firebase-Konsole

Schrieb einen mittleren Beitrag zu diesem Thema.

Hatte ein ähnliches Problem (mit BuildTypes anstelle von Flavours) und behebt es so.

Nutzen Sie das Abhängigkeitsmanagementsystem von Gradle. Ich habe zwei Aufgaben erstellt switchToDebugund switchToRelease. Erfordern, dass jede Zeit ausgeführt assembleReleasewird, die switchToReleaseauch ausgeführt wird. Gleiches gilt für das Debuggen.

def appModuleRootFolder = '.'
def srcDir = 'src'
def googleServicesJson = 'google-services.json'

task switchToDebug(type: Copy) {
    def buildType = 'debug'
    description = 'Switches to DEBUG google-services.json'
    from "${srcDir}/${buildType}"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

task switchToRelease(type: Copy) {
    def buildType = 'release'
    description = 'Switches to RELEASE google-services.json'
    from "${srcDir}/${buildType}/"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

afterEvaluate {
    processDebugGoogleServices.dependsOn switchToDebug
    processReleaseGoogleServices.dependsOn switchToRelease
}

BEARBEITEN: Verwenden Sie processDebugFlavorGoogleServices/ processReleaseFlavorGoogleServicestask, um es auf Geschmacksebene zu ändern.

Nun, ich habe das gleiche Problem und konnte keine perfekte Lösung finden. Es ist nur eine Problemumgehung. Ich frage mich, warum Google nicht über Aromen nachgedacht hat ...? Und ich hoffe, sie werden bald eine bessere Lösung vorschlagen.

Was mache ich:

Ich habe zwei Geschmacksrichtungen, in jede habe ich die entsprechende google-services.json eingefügt: src/flavor1/google-services.jsonund src/flavor2/google-services.json.

Dann kopiere ich in Build Gradle die Datei je nach Geschmack in das app/Verzeichnis:

android {

// set build flavor here to get the right gcm configuration.
//def myFlavor = "flavor1"
def myFlavor = "flavor2"

if (myFlavor.equals("flavor1")) {
    println "--> flavor1 copy!"
    copy {
        from 'src/flavor1/'
        include '*.json'
        into '.'
    }
} else {
    println "--> flavor2 copy!"
    copy {
        from 'src/flavor2/'
        include '*.json'
        into '.'
    }
}

// other stuff
}

Einschränkung: Sie müssen die Gradle jedes Mal myFlavor manuell ändern, wenn Sie für einen anderen Geschmack ausführen möchten (da dieser fest codiert ist).

Ich habe viele Möglichkeiten ausprobiert, um den aktuellen Build-Geschmack so afterEvaluatenah wie möglich zu bringen. Bis jetzt konnte ich keine bessere Lösung finden.

Update, eine andere Lösung: eine google-services.json für alle Geschmacksrichtungen:

Sie können auch unterschiedliche Paketnamen für jede Variante verwenden und dann in der Google-Entwicklerkonsole nicht zwei verschiedene Apps für jede Variante erstellen, sondern nur zwei verschiedene Clients in derselben App. Dann haben Sie nur einen google-services.json, der Ihre beiden Clients enthält. Dies hängt natürlich davon ab, wie Sie das Backend Ihrer Aromen implementieren. Wenn sie nicht getrennt sind, hilft Ihnen diese Lösung nicht weiter.

Gemäß der Antwort von ahmed_khan_89 können Sie Ihren " Kopiercode " in Produktaromen einfügen.

productFlavors {
    staging {
        applicationId = "com.demo.staging"

        println "Using Staging google-service.json"
        copy {
            from 'src/staging/'
            include '*.json'
            into '.'
        }
    }
    production {
        applicationId = "com.demo.production"

        println "Using Production google-service.json"
        copy {
            from 'src/production/'
            include '*.json'
            into '.'
        }
    }
}

Dann müssen Sie die Einstellungen nicht manuell ändern.

Ich verwende die Datei google-services.json, die von hier aus erstellt wurde: https://developers.google.com/mobile/add?platform=android&cntapi=gcm&cnturl=https:%2F%2Fdevelopers.google.com%2Fcloud-messaging % 2Fandroid% 2Fclient & cntlbl = Weiter% 20 Hinzufügen von% 20GCM% 20Support &% 3Fconfigured% 3Dtrue

In der JSON-Struktur gibt es ein JSON-Array namens Clients. Wenn Sie mehrere Geschmacksrichtungen haben, fügen Sie hier einfach die verschiedenen Eigenschaften hinzu.

{
  "project_info": {
    "project_id": "PRODJECT-ID",
    "project_number": "PROJECT-NUMBER",
    "name": "APPLICATION-NAME"
  },
  "client": [
    {
      "client_info": {
        "mobilesdk_app_id": "1:PROJECT-NUMBER:android:HASH-FOR-FLAVOR1",
        "client_id": "android:PACKAGE-NAME-1",
        "client_type": 1,
        "android_client_info": {
          "package_name": "PACKAGE-NAME-1"
        }
      },
      "oauth_client": [],
      "api_key": [],
      "services": {
        "analytics_service": {
          "status": 1
        },
        "cloud_messaging_service": {
          "status": 2,
          "apns_config": []
        },
        "appinvite_service": {
          "status": 1,
          "other_platform_oauth_client": []
        },
        "google_signin_service": {
          "status": 1
        },
        "ads_service": {
          "status": 1
        }
      }
    },
    {
      "client_info": {
        "mobilesdk_app_id": "1:PROJECT-NUMBER:android:HASH-FOR-FLAVOR2",
        "client_id": "android:PACKAGE-NAME-2",
        "client_type": 1,
        "android_client_info": {
          "package_name": "PACKAGE-NAME-2"
        }
      },
      "oauth_client": [],
      "api_key": [],
      "services": {
        "analytics_service": {
          "status": 1
        },
        "cloud_messaging_service": {
          "status": 2,
          "apns_config": []
        },
        "appinvite_service": {
          "status": 1,
          "other_platform_oauth_client": []
        },
        "google_signin_service": {
          "status": 1
        },
        "ads_service": {
          "status": 1
        }
      }
    }
  ],
  "client_info": [],
  "ARTIFACT_VERSION": "1"
}

In meinem Projekt verwende ich dieselbe Projekt-ID. Wenn ich den zweiten Paketnamen in die obige URL einfüge, stellt Google mir eine Datei zur Verfügung, die mehrere Clients in den JSON-Daten enthält.

Entschuldigung für die kompakten JSON-Daten. Ich konnte es nicht richtig formatieren lassen ...

Die Datei google-services.json ist nicht erforderlich, um Benachrichtigungen zu erhalten. Fügen Sie einfach eine Variable für jede Variante in Ihre build.gradle-Datei ein:

buildConfigField "String", "GCM_SENDER_ID", "\"111111111111\""

Verwenden Sie diese Variable BuildConfig.GCM_SENDER_ID anstelle von getString (R.string.gcm_defaultSenderId) bei der Registrierung:

instanceID.getToken(BuildConfig.GCM_SENDER_ID, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

1.) Was macht google-services.json wirklich?

Folgen Sie diesen Anweisungen : https://stackoverflow.com/a/31598587/2382964

2.) Wie wirkt sich die Datei google-services.json auf Ihr Android Studio-Projekt aus?

Folgen Sie diesen Anweisungen : https://stackoverflow.com/a/33083898/2382964

Kurz gesagt für die zweite URL: Wenn Sie in Ihrem Projekt google-services.json hinzufügen, muss in diesem Pfad ein automatisch generierter google-servicesOrdner für die debugVariante vorhanden sein

app/build/generated/res/google-services/debug/values/values.xml

3.) Was tun, um es zu erledigen?

project_levelFügen Sie die Abhängigkeit von Google Services in build.gradle hinzu. Sie können diese auch verwenden, version 3.0.0wenn Sie die Bibliothek app_compact verwenden.

// Top-level build.gradle file
classpath 'com.google.gms:google-services:2.1.2'

Jetzt in app_levelbuild.gradle müssen Sie unten hinzufügen.

// app-level build.gradle file
apply plugin: 'com.google.gms.google-services'

4.) Wo soll die Datei google-service.json in Ihre Struktur eingefügt werden?

Fall 1.) Wenn Sie kein build_flavor haben, legen Sie es einfach in den /app/google-service.jsonOrdner.

Fall 2.) Wenn Sie mehrere build_flavor-Dateien haben und unterschiedliche google_services.json-Dateien darin abgelegt haben app/src/build_flavor/google-service.json.

Fall 3.) Wenn Sie mehrere build_flavor und eine einzelne google_services.json-Datei haben app/google-service.json.

Kein zusätzliches Gradle-Scripting erforderlich.

Google hat begonnen, im Namen von 'android_client_info' einen anderen Paketnamen hinzuzufügen. Es sieht wie unten in google-services.json aus

"android_client_info": {
      "package_name": "com.android.app.companion.dev"
    }

Die folgenden Schritte reichen also aus, um eine andere Auswahl von google-services.json zu haben.

1. Habe 2 Geschmacksrichtungen
2. Fügen Sie der Konfigurationsseite von Google Analystics ein neues Paket für Entwicklergeschmack hinzu und laden Sie google-services.json herunter.
3. Beachten Sie, dass in der neuen Konfigurationsdatei beide Paket-IDs Ihres Geschmacks vorhanden sind
4. Bereiten Sie einen Ihrer Geschmacksrichtungen vor.

Das ist es!..

Wir haben einen anderen Paketnamen für Debug-Builds (* .debug), daher wollte ich etwas, das auf Flavour und BuildType basiert, ohne etwas Flavour-bezogenes in das Muster von schreiben zu müssen processDebugFlavorGoogleServices.

Ich habe in jeder Version einen Ordner mit dem Namen "google-services" erstellt, der sowohl die Debug-Version als auch die Release-Version der JSON-Datei enthält:

Fügen Sie im Abschnitt buildTypes Ihrer Gradle-Datei Folgendes hinzu:

    applicationVariants.all { variant ->
            def buildTypeName = variant.buildType.name
            def flavorName = variant.productFlavors[0].name;

            def googleServicesJson = 'google-services.json'
            def originalPath = "src/$flavorName/google-services/$buildTypeName/$googleServicesJson"
            def destPath = "."

            copy {
                if (flavorName.equals(getCurrentFlavor()) && buildTypeName.equals(getCurrentBuildType())) {
                    println originalPath
                    from originalPath
                    println destPath
                    into destPath
                }
            }
    }

Die richtige JSON-Datei wird automatisch im Stammverzeichnis Ihres App-Moduls kopiert, wenn Sie die Build-Variante wechseln.

Fügen Sie die beiden aufgerufenen Methoden hinzu, um die aktuelle Version und den aktuellen Build-Typ im Stammverzeichnis Ihres build.gradle abzurufen

def getCurrentFlavor() {
    Gradle gradle = getGradle()
    String  tskReqStr = gradle.getStartParameter().getTaskRequests().toString()

    Pattern pattern;

    if( tskReqStr.contains( "assemble" ) )
        pattern = Pattern.compile("assemble(\\w+)(Release|Debug)")
    else
        pattern = Pattern.compile("generate(\\w+)(Release|Debug)")

    Matcher matcher = pattern.matcher( tskReqStr )

    if( matcher.find() ) {
        println matcher.group(1).toLowerCase()
        return matcher.group(1).toLowerCase()
    }
    else
    {
        println "NO MATCH FOUND"
        return "";
    }
}

def getCurrentBuildType() {
    Gradle gradle = getGradle()
    String  tskReqStr = gradle.getStartParameter().getTaskRequests().toString()

        if (tskReqStr.contains("Release")) {
            println "getCurrentBuildType release"
            return "release"
        }
        else if (tskReqStr.contains("Debug")) {
            println "getCurrentBuildType debug"
            return "debug"
        }

    println "NO MATCH FOUND"
    return "";
}

Das war's, Sie müssen sich keine Gedanken über das Entfernen / Hinzufügen / Ändern von Aromen aus Ihrer Gradle-Datei machen, und es wird automatisch das Debug oder die Veröffentlichung google-services.json abgerufen.

Firebase unterstützt jetzt mehrere Anwendungs-IDs mit einer Datei google-services.json.

Dieser Blog-Beitrag beschreibt es im Detail.

Sie erstellen ein übergeordnetes Projekt in Firebase, das Sie für alle Ihre Varianten verwenden. Anschließend erstellen Sie in Firebase unter diesem Projekt separate Android-Anwendungen für jede Anwendungs-ID, die Sie haben.

Wenn Sie alle Ihre Varianten erstellt haben, können Sie eine google-services.json herunterladen, die alle Ihre Anwendungs-IDs unterstützt. Wenn es relevant ist, die Daten separat anzuzeigen (z. B. Crash Reporting), können Sie dies mit einem Dropdown-Menü umschalten.

Laut Firebase-Dokumenten können Sie anstelle von google-services.json auch Zeichenfolgenressourcen verwenden .

Da dieser Anbieter nur Ressourcen mit bekannten Namen liest, können Sie die Zeichenfolgenressourcen auch direkt zu Ihrer App hinzufügen, anstatt das Gradle-Plugin von Google Services zu verwenden. Sie können dies tun durch:

• Entfernen des google-servicesPlugins aus Ihrem root build.gradle
• Löschen Sie die google-services.jsonaus Ihrem Projekt
• Hinzufügen der Zeichenfolgenressourcen direkt
• Löschen des 'com.google.gms.google-services'Apply- Plugins: aus Ihrer App build.gradle

Beispiel strings.xml:

<string name="google_client_id">XXXXXXXXX.apps.googleusercontent.com</string>
<string name="default_web_client_id">XXXX-XXXXXX.apps.googleusercontent.com</string>
<string name="gcm_defaultSenderId">XXXXXX</string>
<string name="google_api_key">AIzaXXXXXX</string>
<string name="google_app_id">1:XXXXXX:android:XXXXX</string>
<string name="google_crash_reporting_api_key">AIzaXXXXXXX</string>
<string name="project_id">XXXXXXX</string>

Fügen Sie dies basierend auf der Antwort von @ ZakTaccardi und unter der Annahme, dass Sie kein einziges Projekt für beide Varianten wünschen, am Ende Ihrer build.gradleDatei hinzu:

def appModuleRootFolder = '.'
def srcDir = 'src'
def googleServicesJson = 'google-services.json'

task switchToStaging(type: Copy) {
    outputs.upToDateWhen { false }
    def flavor = 'staging'
    description = "Switches to $flavor $googleServicesJson"
    delete "$appModuleRootFolder/$googleServicesJson"
    from "${srcDir}/$flavor/"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

task switchToProduction(type: Copy) {
    outputs.upToDateWhen { false }
    def flavor = 'production'
    description = "Switches to $flavor $googleServicesJson"
    from "${srcDir}/$flavor/"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

afterEvaluate {
    processStagingDebugGoogleServices.dependsOn switchToStaging
    processStagingReleaseGoogleServices.dependsOn switchToStaging
    processProductionDebugGoogleServices.dependsOn switchToProduction
    processProductionReleaseGoogleServices.dependsOn switchToProduction
}

Sie müssen die Dateien src/staging/google-services.jsonund haben src/production/google-services.json. Ersetzen Sie die Geschmacksnamen durch die von Ihnen verwendeten.

Ich habe festgestellt, dass das Google Services- Plugin für Projekte, die GCM hinzufügen möchten, ziemlich nutzlos ist. Es wird nur die folgende Datei generiert, die einfach Ihre Projekt-ID als Zeichenfolgenressource hinzufügt:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- Your API key would be on the following line -->
    <string name="gcm_defaultSenderId">111111111111</string>
</resources>

Es scheint, dass Sie es nur benötigen, wenn Sie den Beispielcode wörtlich direkt aus dem Cloud Messaging für Android- Handbuch kopiert haben . Hier ist die Beispielzeile:

String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),              GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

Lösung

Wenn Sie API-Projekte für verschiedene Build-Typen oder Produktvarianten wechseln möchten, können Sie einfach Ihre eigenen Konstanten definieren und beim Aufrufen der getToken()API die entsprechende auswählen .

private static final String SENDER_ID = "111111111111";
private static final String SANDBOX_SENDER_ID = "222222222222";

String token = instanceID.getToken(
        BuildConfig.DEBUG ? SENDER_ID : SANDBOX_SENDER_ID,
        GoogleCloudMessaging.INSTANCE_ID_SCOPE,
        null);

Für Produktaromen

Der obige Code funktioniert zum Umschalten zwischen Debug- und Release-Builds. Für Produktvarianten definieren Sie verschiedene API-Schlüssel in einer Java-Quelldatei und platzieren die Dateien in ihrem entsprechenden Produktvariantenverzeichnis. Als Referenz: Gradle Build-Varianten

AKTUALISIERT:

Informationen zum Firebase-Setup mit Build-Varianten finden Sie in diesem Blog mit detaillierten Anweisungen.

Mit dem Google Services-Plugin soll die Integration von Google-Funktionen vereinfacht werden.

Da es nur Android-Ressourcen aus der Datei google-services.json generiert, negiert eine überkomplizierte Gradle-Logik diesen Punkt, denke ich.

Wenn in den Google-Dokumenten nicht angegeben ist, welche Ressourcen für bestimmte Google-Funktionen benötigt werden, würde ich vorschlagen, die JSON-Datei für jeden relevanten Buildtyp / jede relevante Version zu generieren, zu sehen, welche Ressourcen vom Plugin generiert werden, und diese Ressourcen dann manuell zu platzieren in ihre jeweiligen Verzeichnisse src / buildtypeORflavor / res.

Löschen Sie danach die Verweise auf das Google Services-Plugin und die JSON-Datei, und Sie sind fertig.

Für detaillierte Informationen über das Innenleben von Google-Services Gradle-Plugin siehe meine andere Antwort:

https://stackoverflow.com/a/33083898/433421

Vereinfachen, was @Scotti gesagt hat. Sie müssen mehrere Apps mit unterschiedlichen Paketnamen für ein bestimmtes Projekt erstellen, abhängig von der Produktvariante.

Angenommen, Ihr Projekt ist ABC mit unterschiedlichen Produktvarianten X, Y, wobei X den Paketnamen com.x und Y den Paketnamen com.y hat. Dann müssen Sie in der Firebase-Konsole ein Projekt ABC erstellen, in dem Sie 2 Apps erstellen müssen mit den Paketnamen com.x und com.y. Dann müssen Sie die Datei google-services.json herunterladen, in der sich 2 Client-Info-Objekte befinden, die diese Pakete enthalten, und Sie können loslegen.

Ein Ausschnitt aus dem Json wäre so etwas

{
  "client": [
    {
      "client_info": {
        "android_client_info": {
          "package_name": "com.x"
        }

    {
      "client_info": {
        "android_client_info": {
          "package_name": "com.y"
        }
      ]

    }

In der Tat ist juste one google-services.json im MyApp/app/Verzeichnis gut, es ist kein zusätzliches Skript erforderlich com.google.gms:google-services:3.0.0. Achten Sie jedoch darauf, die Datei google-services.jsonaus dem App-Verzeichnis MyApp/app/src/flavor1/res/zu löschen , um den Fehlertyp zu vermeidenExecution failed for task ':app:processDebugGoogleServices'. > No matching client found for package

Wenn Sie also programmgesteuert google-services.jsonDateien aus all Ihren Varianten in Ihren Stammordner kopieren möchten . Wenn Sie zu einer bestimmten Variante wechseln, finden Sie hier eine Lösung für Sie

android {
  applicationVariants.all { variant ->
    copy {
        println "Switches to $variant google-services.json"
        from "src/$variant"
        include "google-services.json"
        into "."
    }
  }
}

Es gibt eine Einschränkung bei diesem Ansatz, dass Sie eine google-service.jsonDatei in jedem Ihrer Variantenordner haben müssen. Hier ist ein Beispiel.

Sie haben viele Geschmacksrichtungen, was bedeutet, dass Sie viele unterschiedliche Paket-IDs haben, oder? Gehen Sie einfach zu der Seite, auf der Sie Ihre JSON-Datei einrichten / generieren und für jeden Paketnamen konfigurieren. Alles wird zur JSON-Datei hinzugefügt.

Ich bin sehr faul, jetzt ein Bild zu posten, aber im Grunde genommen:

• Gehen Sie zu https://developers.google.com/mobile/add
• Plattform auswählen
• Wählen Sie Ihre App
• WICHTIG : Geben Sie den Namen Ihres Geschmackspakets in das Feld "Name des Android-Pakets" ein.
• ... weiterhin Ihre Konfigurationsdatei erhalten. Lade es herunter!

Wenn Sie die Datei konfigurieren, sehen Sie, dass Google Ihnen den Server-API-Schlüssel + die Absender-ID anzeigt. Und es ist für alle Packungen (Geschmacksrichtungen) gleich

Am Ende benötigen Sie nur eine JSON-Datei für alle Geschmacksrichtungen.

Eine weitere Frage, die Sie testen müssen, wenn Sie sich registrieren, um das Registrierungstoken zu erhalten. Überprüfen Sie, ob es für jeden Geschmack einen Unterschied gibt. Ich rühre es nicht an, aber ich denke, es sollte ein Unterschied sein. Jetzt zu spät und ich bin so müde :) Hoffe es hilft!

Hey Freunde sucht auch nach Namen nur in Kleinbuchstaben, dann bekommst du diesen Fehler nicht

Ich verwende derzeit zwei GCM-Projekt-IDs im selben App-Paket. Ich habe die google-service.json meines ersten GCM-Projekts eingefügt, aber ich wechsle von der ersten zur zweiten und ändere nur die SENDER_ID:

    String token = instanceID.getToken(SENDER_ID,GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

(An dieser Stelle denke ich, dass die Datei google-services.json nicht obligatorisch ist)

Inspiriert von der Antwort von @ ahmed_khan_89 oben. Wir können so direkt in Gradle-Datei behalten.

android{

// set build flavor here to get the right Google-services configuration(Google Analytics).
    def currentFlavor = "free" //This should match with Build Variant selection. free/paidFull/paidBasic

    println "--> $currentFlavor copy!"
    copy {
        from "src/$currentFlavor/"
        include 'google-services.json'
        into '.'
    }
//other stuff
}

Platzieren Sie Ihre "google-services.json" -Datei unter app / src / flavours bzw. dann in build.gradle der App unter android add unten code

gradle.taskGraph.beforeTask { Task task ->
        if (task.name ==~ /process.*GoogleServices/) {
            android.applicationVariants.all { variant ->
                if (task.name ==~ /(?i)process${variant.name}GoogleServices/) {
                    copy {
                        from "/src/${variant.flavorName}"
                        into '.'
                        include 'google-services.json'
                    }
                }
            }
        }
    }