google-services.json pour différents produitsFlavors
J'implémente la nouvelle messagerie Google Cloud en suivant les guides de la page des développeurs de Google ici
J'ai couru et testé avec succès. Mais mon problème est que j’ai différents types de produits avec différents ID application/packageName et différents identifiants de projet Google Cloud Messaging. Le google-services.json doit être placé dans le /app/google-services.json et non dans le dossier flavors.
Existe-t-il un moyen de rendre la configuration google-services.json différente pour de nombreux goûts?
Google a inclus la prise en charge des variantes dans la version 2.0 du plug-in de play services. Depuis cette version du gradle 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 à ces emplacements (étant donné que vous avez un flavor saveur1 et un type de construction debug):
/app/src/flavor1/google-services.json
/app/src/flavor1/debug/google-services.json
/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 flavourDimensions. J'ai libre et payé dans une dimension et Mock & Prod dans l'autre dimension. J'ai aussi 3 buildTypes: debug, release et staging. Voici comment cela se présente dans mon projet pour la version 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 voulez plus de détails sur ce que fait ce plugin avec ces fichiers json, le voici: https://github.com/googlesamples/google-services/issues/54#issuecomment-16582472
Lien vers la documentation officielle: https://developers.google.com/Android/guides/google-services-plugin
Article de blog contenant 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
UPDATE: L'explication suivante concerne un projet Studio Android, avec un projet Firebase et différentes applications Firebase à l'intérieur de ce projet. Si le but est d'avoir différents fichiers JSON pour différentes applications Firebase dans différents projets Firebase dans le même projet Studio Android, (ou si vous ne connaissez pas la différence) regardez ici. .
Vous avez besoin d'une application Firebase par Android ID d'application (généralement le nom du package). Est-il courant d'avoir un identifiant d'application par variante de génération Gradle (cela sera probable si vous utilisez des types de version Gradle et des versions de version Gradle)
À partir de Google Services 3.0 et en utilisant Firebase , il n'est pas nécessaire de créer des fichiers pour différentes saveurs. La création de différents fichiers pour différentes versions peut ne pas être claire ou simple si vous avez des types productFlavours et Build qui composent l’un avec l’autre.
Dans le même fichier, vous aurez toutes les configurations dont vous avez besoin pour tous vos types et versions de construction.
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 construction (debug et release). En fonction de votre configuration, mais il est probable que vous ayez 4 noms de paquet différents, tels que:
- com.stackoverflow.example (live - release)
- com.stackoverflow.example.dev (live - dev)
- com.stackoverflow.example.debug (debug - release)
- com.stackoverflow.example.dev.debug (debug - dev)
Vous avez besoin de 4 applications Android différentes dans la console Firebase. (Sur chacun d'entre eux, vous devez ajouter le SHA-1 pour le débogage et le direct pour chaque ordinateur que vous utilisez)
Lorsque vous téléchargez le fichier google-services.json, l’application que vous téléchargez n’importe pas vraiment; ils contiennent tous 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 vos noms de paquets.
Un point de douleur utiliser pour être le plugin. Pour que cela fonctionne, vous devez localiser le plug-in au bas de votre fichier. Donc cette ligne ..
apply plugin: 'com.google.gms.google-services'
... doit figurer au bas du fichier build.gradle de votre application.
Pour la plupart des choses mentionnées ici, cela s’applique également aux versions précédentes. Je n'ai jamais eu de fichiers différents pour des configurations différentes, mais maintenant avec la console Firebase, c'est plus simple, car ils fournissent un seul fichier avec tout ce dont vous avez besoin pour toutes vos configurations.
A écrit un poste moyen sur cette question.
Avait un problème similaire (en utilisant BuildTypes au lieu de Flavors), et résolu comme tel.
Tirez parti du système de gestion des dépendances de Gradle. J'ai créé deux tâches, switchToDebug et switchToRelease. Exigez que assembleRelease soit exécuté à tout moment, ainsi que switchToRelease. 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 la tâche processDebugFlavorGoogleServices/processReleaseFlavorGoogleServices pour la modifier à un niveau différent.
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 types, dans chacun je mets le google-services.json correspondant: src/flavor1/google-services.json et src/flavor2/google-services.json.
Puis, dans la version de construction, je copie le fichier en fonction de la version dans le répertoire app/:
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 chaque fois que vous le souhaitez. courir pour une saveur différente (parce que c'est codé en dur).
J’ai essayé de nombreuses manières d’obtenir la version actuelle de afterEvaluate close ... impossible d’obtenir une meilleure solution jusqu’à présent.
Mise à jour, une autre solution: un google-services.json pour toutes les variantes:
Vous pouvez également avoir différents noms de package pour chaque version, puis dans la console de développement Google vous n’avez pas à créer deux applications différentes pour chaque version, mais seulement deux clients différents dans la même application. Ensuite, vous aurez un seul google-services.json qui contient vos deux clients. Bien sûr, cela dépend de la manière dont vous implémentez le backend de vos goûts. S'ils ne sont pas séparés, cette solution ne vous aidera pas.
Selon la réponse de ahmed_khan_89 , vous pouvez vous "copier le code" dans les différentes 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 % 2Floud-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 goûts, 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 le fichier json-data.
Désolé pour les données JSON compactes. Je ne pouvais pas le mettre en forme correctement ...
le fichier google-services.json n’est pas nécessaire pour recevoir des notifications. Ajoutez simplement une variable pour chaque version 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
en bref pour la deuxième URL, si vous ajoutez google-services.json dans votre projet, un dossier google-services généré automatiquement doit être créé pour la variante debug de ce chemin.
app/build/generated/res/google-services/debug/values/values.xml
3.) Que faire, que faire?
ajoutez la dépendance de google-services dans project_level build.gradle, vous pouvez également utiliser version 3.0.0 si vous utilisez la bibliothèque app_compact.
// Top-level build.gradle file
classpath 'com.google.gms:google-services:2.1.2'
maintenant dans app_level build.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 build_flavor, mettez le dans le dossier /app/google-service.json.
cas 2.) si vous avez plusieurs build_flavor et que vous avez différents fichiers google_services.json placés dans 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 placé dans app/google-service.json.
Nous avons un nom de paquet différent pour les builds de débogage (* .debug). Je voulais donc quelque chose qui fonctionne à partir de la saveur et du type de construction, sans avoir à écrire quoi que ce soit en rapport avec la saveur dans le modèle processDebugFlavorGoogleServices.
J'ai créé un dossier nommé "google-services" dans chaque version, contenant à la fois la version de débogage et la version 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 utiliserez une variante de construction.
Ajoutez les deux méthodes appelées pour obtenir la version actuelle et le type de construction à 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 "";
}
C'est tout, vous n'avez pas à vous soucier de supprimer/ajouter/modifier des variantes de votre fichier Gradle, et le fichier de débogage ou de publication google-services.json est automatiquement généré.
Firebase prend désormais en charge plusieurs identifiants d’application avec un seul fichier google-services.json.
Cet article 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 fichier 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'est-à-dire le rapport d'incident), vous pouvez basculer vers cela avec une liste déroulante.
MIS À JOUR:
Pour ce qui est de l’installation de Firebase avec les variantes de construction, veuillez vous référer à ce blog qui contient des instructions détaillées.
Sur la base de la réponse de @ ZakTaccardi, et en supposant que vous ne souhaitiez pas un seul projet pour les deux variantes, ajoutez ceci à la fin de votre fichier build.gradle:
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.json et src/production/google-services.json. Remplacez les noms de saveur pour ceux que vous utilisez.
Pas besoin de script supplémentaire.
Google a commencé à ajouter un nom de package différent au nom de "Android_client_info". Cela ressemble à ci-dessous dans google-services.json
"Android_client_info": {
"package_name": "com.Android.app.companion.dev"
}
les étapes suivantes sont donc suffisantes pour permettre une sélection différente dans google-services.json.
- Avoir 2 saveurs
- Ajoutez un nouveau paquet dev flavour à la page de configuration de google analystics et téléchargez google-services.json.
- Notez que dans le nouveau fichier de configuration, les deux ID de paquet de votre saveur sont présents.
- Préparez n'importe lequel de vos arômes.
C'est ça!..
J'ai trouvé que le plugin google-services est tout à fait inutile pour les projets qui souhaitent ajouter GCM. Il ne génère que 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 for Android . Voici la ligne d'exemple:
String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
Solution
Si vous voulez pouvoir changer de projet d'API pour différents types de construction ou types de produit, vous pouvez simplement définir vos propres constantes et choisir celle qui convient lorsque vous appelez l'API getToken().
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 arômes de produits
Le code ci-dessus fonctionne pour basculer entre les versions de débogage et de publication. Pour les variantes de produit, définissez différentes clés API dans un fichier source Java et placez les fichiers dans le répertoire de la version correspondante. Pour référence: Varile Build Variants
L'intérêt 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, une logique de gradation trop compliquée annule ce point, je pense.
Donc, si les documents Google ne précisent pas quelles ressources sont nécessaires pour certaines fonctionnalités de Google, je suggérerais de générer le fichier JSON pour chaque type de construction/saveur pertinent, de voir quelles ressources sont générées par le plugin, puis de les placer manuellement. dans leurs répertoires respectifs src/buildtypeORflavor/res.
Supprimez les références au plug-in google-services et au fichier JSON par la suite, et vous avez terminé.
Pour plus d'informations sur le fonctionnement interne de google-services gradle-plugin, reportez-vous à mon autre réponse:
Simplifier ce que @Scotti a dit. Vous devez créer plusieurs applications avec un nom de package différent pour un projet particulier, en fonction de la version du produit.
Supposons que votre projet est ABC avec différents types de produits 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 paquetages 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 paquets et vous serez prêt à partir.
Snippet of the 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"
}
]
}
Hey Friends cherche aussi le nom utilisé seulement en minuscule, alors vous ne recevez pas cette erreur
En effet, juste un google-services.json dans le répertoire MyApp/app/ est bon, pas besoin de script supplémentaire avec com.google.gms:google-services:3.0.0. Mais veillez à supprimer le fichier google-services.json du répertoire de l'application MyApp/app/src/flavor1/res/ pour éviter le type d'erreur Execution failed for task ':app:processDebugGoogleServices'. > No matching client found for package.
Vous avez beaucoup de saveurs, cela signifie donc que vous aurez de nombreux identifiants de paquet, n'est-ce pas? Donc, allez simplement à la page où vous installez/générez votre fichier json et config pour chaque nom de paquet. Tout cela va ajouter au fichier JSON.
Je suis très paresseux pour poster une photo maintenant, mais en gros:
- allez à https://developers.google.com/mobile/add
- sélectionner la plate-forme
- sélectionnez votre application
- IMPORTANT: tapez le nom de votre paquet de saveur dans le champ "nom du paquet Android"
- ... continuez à obtenir 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 pareil pour tous les paquets (saveurs)
À la fin, vous n'avez besoin que d'un seul fichier json pour toutes les variantes.
Une autre question ici que vous devez tester lorsque vous vous inscrivez pour obtenir un jeton d’inscription, vérifiez s’il ya une différence pour chaque saveur. Je n'en parle pas mais il pense que cela devrait faire la différence. Trop tard maintenant et j'ai tellement sommeil :) J'espère que ça vous aidera!
Donc, si vous voulez copier par programme le fichier google-services.json 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 "."
}
}
}
Un inconvénient à cette approche est que vous devez avoir le fichier google-service.json dans chacun de vos dossiers de variantes. En voici un exemple. 
J'utilise actuellement deux identifiants de projet GCM dans le même package d'application. Je mets le google-service.json de mon premier projet GCM mais je passe du premier au deuxième en ne modifiant que le SENDER_ID:
String token = instanceID.getToken(SENDER_ID,GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
(À ce stade, je pense que google-services.json n'est pas obligatoire)
Placez votre fichier "google-services.json" sous app/src/flavors respectivement, puis dans build.gradle of app, sous Android ajoutez le code ci-dessous.
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'
}
}
}
}
}
Inspiré par @ ahmed_khan_89, répondez 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
}