google-services.json pour différents produits

Mise à jour: GCM est obsolète, utilisez FCM

J'implémente la nouvelle messagerie Google Cloud en suivant les guides de la page des développeurs Google ici

J'ai réussi à l'exécuter et à le tester. Mais mon problème est maintenant que j'ai différentes saveurs de produits avec différents ID d'application / packageName et différents ID de projet de messagerie Google Cloud. Ils google-services.jsondoivent être placés dans le /app/google-services.jsondossier not the flavors.

Existe-t-il un moyen de rendre la google-services.jsonconfiguration différente pour de nombreuses saveurs?

Google a pris en charge les saveurs dans la version 2.0 du plugin des services de jeu. Depuis cette version dugradle plugin com.google.gms:google-services:2.0.0-alpha3

tu peux le faire

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

La version 3.0.0 du plugin recherche le fichier json dans ces emplacements (étant donné que vous avez un flavorflaveur1 et un type de build debug):

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

Cela a fonctionné pour moi même en utilisant des flavourDimensions. J'ai gratuit et payé dans une dimension et Mock & Prod dans l'autre dimension. J'ai également 3 buildTypes: debug, release et staging. Voici à quoi cela ressemble dans mon projet pour la saveur FreeProd:

Le nombre de fichiers google-services.json dépendra des caractéristiques de votre projet, mais vous aurez besoin d'au moins un fichier json pour chaque projet Google.

Si vous souhaitez plus de détails sur ce que ce plugin fait avec ces fichiers json, le voici: https://github.com/googlesamples/google-services/issues/54#issuecomment-165824720

Lien vers les documents officiels: https://developers.google.com/android/guides/google-services-plugin

Article de blog avec des informations mises à jour: https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

Et allez ici pour vérifier la dernière version de ce plugin: https://bintray.com/android/android-tools/com.google.gms.google-services/view

MISE À JOUR: L'explication suivante concerne un projet Android Studio, avec un projet Firebase et différentes applications Firebase dans ce projet. Si l'objectif est d'avoir différents fichiers JSON pour différentes applications Firebase dans différents projets Firebase dans le même projet Android Studio, (ou si vous ne savez pas quelle est la différence), regardez ici. .

Vous avez besoin d'une application Firebase par ID d'application Android (généralement le nom du package). Il est courant d'avoir un ID d'application par variante de construction Gradle (cela sera probable si vous utilisez des types de construction Gradle et des versions de construction Gradle)

Depuis Google Services 3.0 et l'utilisation de Firebase, il n'est pas nécessaire de créer des fichiers différents pour différentes saveurs. La création de fichiers différents pour différentes saveurs peut ne pas être claire ou simple dans le cas où vous avez des types de ProductFlavours et Build qui se composent les uns avec les autres.

Dans le même fichier, vous aurez toutes les configurations dont vous avez besoin pour tous vos types et saveurs de build.

Dans la console Firebase, vous devez ajouter une application par nom de package. Imaginez que vous ayez 2 versions (dev et live) et 2 types de build (debug et release). En fonction de votre configuration, mais il est probable que vous ayez 4 noms de packages différents comme:

• com.stackoverflow.example (en direct - sortie)
• com.stackoverflow.example.dev (live - dev)
• com.stackoverflow.example.debug (débogage - version)
• com.stackoverflow.example.dev.debug (débogage - dev)

Vous avez besoin de 4 applications Android différentes dans la console Firebase. (Sur chacun, vous devez ajouter le SHA-1 pour le débogage et vivre pour chaque ordinateur que vous utilisez)

Lorsque vous téléchargez le fichier google-services.json, en réalité, peu importe l'application que vous téléchargez, elles contiennent toutes les mêmes informations relatives à toutes vos applications.

Vous devez maintenant localiser ce fichier au niveau de l'application (app /).

Si vous ouvrez ce fichier, vous verrez que si contient toutes les informations pour tous les noms de vos packages.

Un point douloureux était le plugin. Pour le faire fonctionner, vous devez localiser le plugin au bas de votre fichier. Donc cette ligne ..

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

... doit se trouver en bas du fichier build.gradle de votre application.

Pour la plupart des éléments mentionnés ici, cela s'applique également aux versions précédentes. Je n'ai jamais eu de fichiers différents pour différentes configurations, mais maintenant avec la console Firebase est plus facile car ils fournissent un seul fichier avec tout ce dont vous avez besoin pour toutes vos configurations.

• Documents Firebase
• Messagerie cloud Firebase
• Console Firebase

A écrit un article moyen sur cette question.

A eu un problème similaire (en utilisant BuildTypes au lieu de Flavors), et l'a corrigé comme ça.

Profitez du système de gestion des dépendances de Gradle. J'ai créé deux tâches, switchToDebuget switchToRelease. Exiger que n'importe quel moment assembleReleasesoit exécuté, c'est switchToReleaseaussi exécuté. Idem pour le débogage.

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
}

EDIT: utilisez processDebugFlavorGoogleServices/ processReleaseFlavorGoogleServicestask pour le modifier au niveau de chaque saveur.

Eh bien, je rencontre le même problème et je n'ai pas pu trouver de solution parfaite. C'est juste une solution de contournement. Je me demande comment Google n'a pas pensé aux saveurs ...? Et j'espère qu'ils proposeront bientôt une meilleure solution.

Que suis-je en train de faire:

J'ai deux saveurs, dans chacune je mets le google-services.json correspondant: src/flavor1/google-services.jsonet src/flavor2/google-services.json.

Ensuite, dans le build gradle, je copie le fichier en fonction de la saveur dans le app/répertoire:

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
}

Limitation: vous devrez changer myFlavor manuellement de gradle chaque fois que vous souhaitez exécuter pour une saveur différente (car il est codé en dur).

J'ai essayé de nombreuses façons d'obtenir la version actuelle de build comme afterEvaluateclose ... je n'ai pas pu trouver de meilleure solution jusqu'à présent.

Mise à jour, une autre solution: un google-services.json pour toutes les saveurs:

Vous pouvez également avoir des noms de packages différents pour chaque saveur, puis dans la console de développeur Google, vous n'avez pas à créer deux applications différentes pour chaque saveur, mais seulement deux clients différents dans la même application. Ensuite, vous n'en aurez qu'un google-services.jsonqui contiendra vos deux clients. Bien sûr, cela dépend de la façon dont vous implémentez le backend de vos saveurs. S'ils ne sont pas séparés, cette solution ne vous aidera pas.

Selon la réponse de ahmed_khan_89 , vous pouvez mettre votre "code de copie" dans les versions du produit.

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 '.'
        }
    }
}

Ensuite, vous n'avez pas à changer les paramètres manuellement.

J'utilise le fichier google-services.json, créé à partir d'ici: https://developers.google.com/mobile/add?platform=android&cntapi=gcm&cnturl=https:%2F%2Fdevelopers.google.com%2Fcloud-messaging % 2Fandroid% 2Fclient & cntlbl = Continue% 20Adding% 20GCM% 20Support &% 3Fconfigured% 3Dtrue

Dans la structure JSON, il existe un tableau JSON appelé clients. Si vous avez plusieurs saveurs, ajoutez simplement les différentes propriétés ici.

{
  "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"
}

Dans mon projet, j'utilise le même identifiant de projet et lorsque j'ajoute le deuxième nom de package dans l'URL ci-dessus, google me fournit un fichier contenant plusieurs clients dans les données json.

Désolé pour les données JSON compactes. Je n'ai pas pu le formater correctement ...

Le fichier google-services.json est inutile pour recevoir des notifications. Ajoutez simplement une variable pour chaque saveur dans votre fichier build.gradle:

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

Utilisez cette variable BuildConfig.GCM_SENDER_ID au lieu de getString (R.string.gcm_defaultSenderId) lors de l'enregistrement:

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

1.) Que fait vraiment google-services.json?

Suivez ceci : https://stackoverflow.com/a/31598587/2382964

2.) Comment le fichier google-services.json affecte-t-il votre projet de studio Android?

Suivez ceci: https://stackoverflow.com/a/33083898/2382964

juste en abrégé pour la deuxième URL, si vous ajoutez google-services.json dans votre projet, il doit y avoir un google-servicesdossier généré automatiquement pour la debugvariante dans ce chemin

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

3.) Que faire, pour le faire?

ajouter la dépendance google-services dans project_levelbuild.gradle, vous pouvez également l'utiliser version 3.0.0si vous utilisez la bibliothèque app_compact.

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

maintenant dans app_levelbuild.gradle, vous devez ajouter en bas.

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

4.) Où placer le fichier google-service.json dans votre structure.

cas 1.) si vous n'avez pas de build_flavor il suffit de le mettre à l'intérieur /app/google-service.json dossier.

cas 2.) si vous avez plusieurs build_flavor et que vous avez des fichiers google_services.json différents à l'intérieur app/src/build_flavor/google-service.json .

cas 3.) si vous avez plusieurs build_flavor et que vous avez un seul fichier google_services.json à l'intérieur app/google-service.json.

Pas besoin de script Gradle supplémentaire.

Google a commencé à ajouter un nom de package différent au nom de «android_client_info». Il ressemble à ci-dessous dans google-services.json

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

ainsi, les étapes suivantes suffisent pour avoir une sélection google-services.json différente.

1. Avoir 2 saveurs
2. Ajoutez un nouveau package de version de développement à la page de configuration de Google Analytics et téléchargez google-services.json.
3. Remarquez dans le nouveau fichier de configuration, les deux identifiants de package de votre saveur sont là
4. Préparez n'importe laquelle de vos saveurs.

C'est ça!..

Nous avons un nom de package différent pour les versions de débogage (* .debug), donc je voulais quelque chose qui fonctionne basé sur la saveur et le buildType, sans avoir à écrire quoi que ce soit lié à la saveur dans le modèle de processDebugFlavorGoogleServices.

J'ai créé un dossier nommé "google-services" dans chaque version, contenant à la fois la version de débogage et la version finale du fichier json:

Dans la section buildTypes de votre fichier gradle, ajoutez ceci:

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

Il copiera automatiquement le bon fichier json à la racine de votre module d'application lorsque vous changerez de variante de build.

Ajoutez les deux méthodes appelées pour obtenir la saveur actuelle et le type de construction actuel à la racine de votre build.gradle

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

Voilà, vous n'avez pas à vous soucier de supprimer / ajouter / modifier des saveurs de votre fichier gradle, et il obtient automatiquement le débogage ou la version google-services.json.

Firebase prend désormais en charge plusieurs ID d'application avec un seul fichier google-services.json.

Ce billet de blog le décrit en détail.

Vous allez créer un projet parent dans Firebase que vous utiliserez pour toutes vos variantes. Vous créez ensuite des applications Android distinctes dans Firebase sous ce projet pour chaque ID d'application dont vous disposez.

Lorsque vous avez créé toutes vos variantes, vous pouvez télécharger un google-services.json qui prend en charge tous les identifiants de vos applications. Lorsqu'il est pertinent de voir les données séparément (c.-à-d. Rapports de plantage), vous pouvez les basculer avec une liste déroulante.

Selon les documents Firebase, vous pouvez également utiliser des ressources de chaîne au lieu de google-services.json .

É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 Gradle des services Google. Vous pouvez le faire en:

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

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

Sur la base de la réponse de @ ZakTaccardi, et en supposant que vous ne voulez pas un seul projet pour les deux versions, ajoutez ceci à la fin de votre build.gradlefichier:

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
}

Vous devez avoir les fichiers src/staging/google-services.jsonet src/production/google-services.json. Remplacez les noms de saveur par ceux que vous utilisez.

J'ai trouvé que le plugin google-services est assez inutile pour les projets qui souhaitent ajouter GCM. Il génère uniquement le fichier suivant qui ajoute simplement votre ID de projet en tant que ressource de chaîne:

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

Il semble que vous n'en ayez besoin que si vous avez copié l'exemple de code textuellement directement à partir du guide Cloud Messaging pour Android . Voici l'exemple de ligne:

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

Solution

Si vous souhaitez pouvoir changer de projet d'API pour différents types de build ou différentes versions de produit, vous pouvez simplement définir vos propres constantes et choisir celle qui convient lorsque vous appelez le getToken() API.

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

Pour les saveurs des produits

Le code ci-dessus fonctionne pour basculer entre les versions de débogage et de version. Pour les versions de produit, vous devez définir différentes clés d'API dans un fichier source java et placer les fichiers dans leur répertoire de version de produit correspondant. Pour référence: Gradle Build Variants

MISE À JOUR:

En termes de configuration de Firebase avec des variantes de build, veuillez vous référer à ce blog qui contient des instructions détaillées.

Le but du plugin google-services est de simplifier l'intégration des fonctionnalités de Google.

Comme il ne génère que des ressources Android à partir du fichier google-services.json, la logique gradle trop compliquée nie ce point, je pense.

Donc, si les documents Google ne disent pas quelles ressources sont nécessaires pour des fonctionnalités Google spécifiques, je suggérerais de générer le fichier JSON pour chaque type de construction / saveur pertinent, voir quelles ressources sont générées par le plugin, puis mettre ces ressources manuellement dans leurs répertoires respectifs src / buildtypeORflavor / res.

Supprimez les références au plugin google-services et au fichier JSON après cela, et vous avez terminé.

Pour des informations détaillées sur le fonctionnement interne du plugin gradle google-services, voir mon autre réponse:

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

Simplifier ce que @Scotti a dit. Vous devez créer des applications multiples avec un nom de package différent pour un projet particulier en fonction de la saveur du produit.

Supposons que votre projet soit ABC ayant différentes saveurs de produit X, Y où X a un nom de package com.x et Y a un nom de package com.y, puis dans la console Firebase, vous devez créer un projet ABC dans lequel vous devez créer 2 applications avec les noms de package com.x et com.y. Ensuite, vous devez télécharger le fichier google-services.json dans lequel il y aura 2 objets client-info qui contiendront ces pacakges et vous serez prêt à partir.

L'extrait du json serait quelque chose comme ça

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

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

    }

En effet, juste un google-services.json dans le MyApp/app/répertoire est bon, pas besoin de script supplémentaire avec com.google.gms:google-services:3.0.0. Mais attention à supprimer le fichier google-services.jsondu répertoire de l'application MyApp/app/src/flavor1/res/pour éviter le type d'erreurExecution failed for task ':app:processDebugGoogleServices'. > No matching client found for package

Donc, si vous souhaitez copier par programme le google-services.jsonfichier de toutes vos variantes dans votre dossier racine. Lorsque vous passez à une variante spécifique, voici une solution pour vous

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

Il y a une mise en garde à cette approche: vous devez avoir un google-service.jsonfichier dans chacun de vos dossiers de variantes, voici un exemple.

Vous avez beaucoup de saveurs, cela signifie donc que vous aurez de nombreux identifiants de packages différents, non? Donc, allez simplement sur la page où vous configurez / générez votre fichier json et configurez pour chaque nom de package. Tout cela s'ajoutera au fichier json.

Je suis très paresseux pour poster une photo maintenant, mais en gros:

• accédez à https://developers.google.com/mobile/add
• sélectionner la plateforme
• sélectionnez votre application
• IMPORTANT : saisissez le nom de votre package de saveurs dans le champ "nom du package android"
• ... continuez à récupérer votre fichier de configuration. Télécharge le!

Lorsque vous configurez le fichier, vous pouvez voir que Google vous montre la clé API du serveur + l'ID de l'expéditeur. Et c'est la même chose pour tous les packages (saveurs)

À la fin, vous n'avez besoin que d'un seul fichier json pour toutes les saveurs.

Une autre question ici que vous devez tester lorsque vous vous inscrivez pour obtenir un jeton d'enregistrement, vérifiez s'il y a une différence pour chaque saveur. Je n'y touche pas mais il pense que ça devrait être différent. Trop tard maintenant et j'ai tellement sommeil :) J'espère que ça aide!

Hey Friends recherche également l'utilisation du nom uniquement en minuscules, alors vous n'obtenez pas cette erreur

J'utilise actuellement deux identifiants de projet GCM dans le même package d'application. J'ai mis le google-service.json de mon premier projet GCM mais je passe du premier au second en ne changeant que le SENDER_ID:

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

(À ce stade, je pense que le google-services.json n'est pas obligatoire)

Inspiré par la réponse de @ ahmed_khan_89 ci-dessus. On peut directement garder comme ça dans le fichier gradle.

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
}

Placez votre fichier "google-services.json" sous app / src / flavors respectivement puis dans build.gradle de l'application, sous android ajoutez ci-dessous le 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'
                    }
                }
            }
        }
    }