google-services.json pour différents types de produits

mise à JOUR: L'explication suivante est pour un Android Studio de projet, avec un Firebase Projet et les différents Firebase Applications à 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 à l'intérieur du 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 nom du paquet). Il est courant d'avoir un ID D'Application par variante de construction de Grable151960920 (cela sera probablement le cas si vous utilisez les types de construction de Grable151960920 et les saveurs de construction de Grable151960920)."

à partir de "Google Services 3.0 et en utilisant Firebase il n'est pas nécessaire de créer des fichiers différents pour des saveurs différentes. La création de fichiers différents pour des saveurs différentes peut ne pas être claire ou simple dans le cas où vous avez flavours produit et construisent des types qui 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 construction.

dans la console Firebase, vous devez ajouter une application par nom de paquet. Imaginez que vous ayez 2 saveurs (dev et live) et 2 types de construction (debug et release). Selon votre configuration, mais il est probable que vous ayez 4 noms de paquets différents comme:

• COM.stackoverflow.exemple (diffusion en direct)
• com.stackoverflow.exemple.dev (live - dev)
• com.stackoverflow.exemple.débogage (debug - libération)
• com.stackoverflow.exemple.dev.debug (debug - dev)

vous avez besoin de 4 Applications Android différentes dans la Console Firebase. (Pour chaque ordinateur, vous devez ajouter le SHA-1 pour le débogage et le live pour chaque ordinateur que vous utilisez)

quand vous télécharger les services google.fichier json, en fait, il n'importe pas vraiment de ce que l'application que vous téléchargez, tous contiennent les mêmes informations pour toutes vos applications.

Maintenant vous devez localiser ce fichier dans app level (app/).

si vous ouvrez ce fichier, vous verrez que if contient toutes les informations pour tous les noms de paquets.

Une douleur au point d'utilisation pour le plugin. Pour que cela fonctionne, vous devez localiser le plugin au bas de votre fichier. Donc cette ligne..

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

...doit être sur le fond de votre construction d'application.dossier gradle.

Pour la plupart des dit ici, il s'applique 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 parce qu'ils fournissent un seul fichier avec tout ce dont vous avez besoin pour toutes vos configurations.

• Firebase Docs
• Firebase Messagerie En Nuage
• Firebase Console

a écrit un Post moyen sur cette question.

a eu un problème similaire (en utilisant des types de construction au lieu de saveurs), et l'a corrigé comme si.

profitez du système de gestion des dépendances de Gradle. J'ai créé deux tâches, switchToDebug et switchToRelease . Exiger que tout le temps assembleRelease est exécuté, que switchToRelease est également exécuter. De même 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 / processReleaseFlavorGoogleServices tâche pour le modifier à un niveau de per-saveur.

Eh bien, j'ai 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 vont proposer bientôt une meilleure solution.

ce que je fais:

j'ai deux saveurs, dans chacun je mets les google-services correspondants.json: src/flavor1/google-services.json et src/flavor2/google-services.json .

puis dans build gradle je copie le fichier en fonction de la saveur au 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 dans gradle chaque fois que vous voulez courir pour une saveur différente (parce que c'est durcodé).

j'ai essayé de nombreuses façons d'obtenir la saveur de construction actuelle comme afterEvaluate proche... ne pouvait pas faire mieux de la solution jusqu'à présent.

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

vous pouvez également, avoir des noms de paquets différents pour chaque saveur et puis dans le Google developer console vous ne devez pas créer deux applications différentes pour chaque saveur, mais juste deux clients différents dans la même application. Vous n'aurez alors qu'un seul google-services.json qui contient vos deux clients. Bien sûr, cela dépend de la façon dont vous mettez en œuvre l'arrière-plan de vos saveurs. Si ils ne sont pas séparé alors cette solution ne vous aidera pas.

selon ahmed_khan_89 ' S réponse, vous pouvez vous mettre "code de copie" à l'intérieur des saveurs de 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 '.'
        }
    }
}

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

google-services.le fichier json n'est pas nécessaire pour recevoir des notifications. Il suffit d'ajouter une variable pour chaque saveur dans votre construction.gradle fichier:

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

j'utilise les services google.fichier 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 y a un tableau JSON appelé clients. Si vous avez plusieurs saveurs, il suffit d'ajouter 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 ID de projet et lorsque j'ajoute le deuxième nom de paquet dans l'url ci-dessus, google me fournit un fichier contenant plusieurs clients dans les données json.

désolé pour le compact JSON-data. Je ne pouvais pas le faire correctement mis en forme...

nous avons un nom de paquet différent pour debug builds (*.debug) donc je voulais quelque chose qui fonctionne basé sur la saveur et buildType, sans avoir à écrire quoi que ce soit de 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 de sortie du fichier json:

In 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 va copier le bon fichier json à la racine de votre module app automatiquement lorsque vous changez la variante de construction.

ajoutez les deux méthodes appelées pour obtenir la saveur et le type de construction actuels à la racine de votre construction.Grad

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 les saveurs de votre fichier gradle, et il obtenir le debug ou la sortie de google-services.json automatiquement.

Firebase prend désormais en charge plusieurs identifiants d'application avec un seul service google.fichier json.

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

vous créerez un projet parent dans Firebase que vous utiliserez pour toutes vos variantes. Vous créez alors des applications Android distinctes dans Firebase sous ce projet pour chaque id d'application que vous avez.

quand vous avez créé toutes vos variantes, vous pouvez télécharger un google-services.json qui prend en charge toutes vos applications ids. Quand il est pertinent de voir les données séparément (C.-à-d. rapports de collision), vous pouvez basculer que par une baisse.

basé sur la réponse de @ZakTaccardi, et en supposant que vous ne voulez pas un seul projet pour les deux saveurs, ajoutez ceci à la fin de votre build.gradle fichier:

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 . Remplacer les noms de saveur pour ceux que vous utilisez.

j'ai trouvé que le google-services plugin est tout à fait inutile pour les projets qui veulent ajouter GCM. Il ne génère que le fichier suivant qui ajoute simplement votre ID de projet comme une ressource de chaîne de caractères:

<?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é mot à mot le code échantillon du guide messagerie Cloud pour Android . Voici l'exemple de la ligne:

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

Solution

si vous voulez être en mesure de changer de projets API pour différents types de construction ou des saveurs de produits, vous pouvez juste 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);

"151950920 De Produits" Saveurs

le code ci-dessus fonctionne pour passer entre les constructions debug et release. Pour les saveurs de produits, vous définiriez différentes clés API dans un fichier source java et placer les fichiers dans leur produit correspondant saveur répertoire. Pour référence: Gradle Build variantes

pas besoin de script gradle supplémentaire.

Google a commencé à ajouter un nom de paquet différent dans le nom de 'android_client_info'. Il ressemble ci-dessous dans google-services.json

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

donc, les étapes suivantes sont suffisantes pour avoir différents services google.json sélection.

1. ont 2 saveurs
2. Ajouter un nouveau paquet dev flavour à la page de configuration de google analystics et Télécharger google-services.json.
3. avis dans le nouveau fichier de configuration, les deux identifiants du paquet de votre flavour sont présents
4. préparez n'importe laquelle de vos saveurs.

C'est ça!..

1.) Qu'est-ce que google-services.json le fait vraiment?

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

2.) Comment fait google-services.le fichier JSON affecte votre projet android studio?

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

en bref pour la deuxième url, si vous ajoutez google-services.json dans votre projet il doit y avoir un dossier google-services généré automatiquement pour debug variante dans ce chemin

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

3.) Quoi faire, pour le faire faire?

ajouter la dépendance de google-services dans project_level construire.gradle, vous pouvez également utiliser version 3.0.0 si vous utilisez app_compact library.

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

maintenant app_level construire.Grad que vous devez ajouter au fond.

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

4.) où mettre google-service.fichier json dans votre structure.

cas 1.) si vous n'avez pas de build_flavor, mettez-le dans le dossier /app/google-service.json .

affaire 2.) si vous avez plusieurs build_flavor et que vous avez différents google_services.les fichiers json mis dans app/src/build_flavor/google-service.json .

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

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

depuis qu'il ne génère des ressources android à partir des services google.dossier json, la logique trop compliquée de Grad-logic nie ce point, je pense.

donc si les Google-docs ne disent pas quelles ressources sont nécessaires pour les fonctionnalités spécifiques de Google, je suggérerais de générer le fichier JSON pour chaque buildtype/flavor pertinent, voir quelles ressources sont générées par le plugin et ensuite mettre ces ressources manuellement dans leurs répertoires src/buildtypeORflavor/res respectifs.

supprimer les références à google-services plugin et le JSON-fichier après cela, et vous êtes fait.

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

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

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

supposons que votre projet est ABC ayant différentes saveurs de produit X, Y où X a un nom de paquet com.x et Y ont un nom de paquet com.puis dans la console firebase vous devez créer un projet ABC dans lequel vous devez créer 2 applications avec les noms de paquets com.x et com.y. Ensuite, vous devez télécharger le google-services.fichier json dans lequel il y aura 2 objets client-info qui contiendront ces pacakges et vous serez bon à aller.

un 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"
        }
      ]

    }

vous avez beaucoup de goût, donc cela signifie que vous aurez beaucoup de différence d'identification de paquet, non? Donc, allez simplement à la page où vous avez configuré/généré votre fichier json et votre configuration pour chaque nom de paquet. Tout cela va ajouter de fichier json.

je suis paresseux de poster image maintenant, mais essentiellement:

• passer à https://developers.google.com/mobile/add
• sélectionnez la plate-forme
• sélectionnez votre app
• IMPORTANT : tapez le nom du paquet flavor dans le champ "Nom du paquet android"
• ... continuez à récupérer votre fichier de configuration. Le télécharger!

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

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

Une question de plus ici que vous devez tester lorsque vous vous inscrivez pour obtenir le jeton D'enregistrement, vérifiez si est la différence pour chaque saveur. Je n'y touche pas, mais ça devrait faire une différence. Trop tard maintenant, et j'ai encore dormi :) j'Espère que cela aide!

Hey les Amis, on cherche le nom de l'utiliser uniquement les minuscules alors u ne recevez pas ce message d'erreur

UPDATED:

en termes de configuration de base de feu avec des variantes de construction, s'il vous plaît se référer à ce blog qui a des instructions détaillées.

j'utilise actuellement deux Id de projet GCM dans le même paquet app. J'ai mis le google-service.json de mon premier projet GCM mais je passe du premier au second en changeant seulement le SENDER_ID:

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

(à ce point je pense que les services google.json n'est pas obligatoire )

inspiré par la réponse de @ahmed_khan_89 ci-dessus. On peut garder ça directement 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" Google-services.fichier JSON sous app / src / flavors respectivement puis dans la construction.grad de l'application, sous android Ajouter 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'
                    }
                }
            }
        }
    }

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