android - plugin - google-services.json para diferentes productos
google services json android studio (23)
1.) ¿Qué hace realmente google-services.json?
Siga esto: https://stackoverflow.com/a/31598587/2382964
2.) ¿Cómo afecta el archivo google-services.json a su proyecto de estudio de Android?
Siga esto: https://stackoverflow.com/a/33083898/2382964
para abreviar la segunda url, si agrega google-services.json en su proyecto, debe haber una carpeta de
google-services
generada automáticamente para la variante de
debug
en esta ruta
app/build/generated/res/google-services/debug/values/values.xml
3.) ¿Qué hacer para hacerlo?
agregue la dependencia de google-services en
project_level
build.gradle, también puede usar la
version 3.0.0
si está usando la biblioteca app_compact.
// Top-level build.gradle file
classpath ''com.google.gms:google-services:2.1.2''
ahora en
app_level
build.gradle tienes que agregar en la parte inferior.
// app-level build.gradle file
apply plugin: ''com.google.gms.google-services''
4.) Dónde colocar el archivo google-service.json en su estructura.
caso 1.) si no tiene build_flavor simplemente
/app/google-service.json
dentro de la carpeta
/app/google-service.json
.
caso 2.) si tiene múltiples build_flavor y tiene diferentes archivos google_services.json colocados dentro de
app/src/build_flavor/google-service.json
.
caso 3.) si tiene múltiples build_flavor y tiene un solo archivo google_services.json dentro de
app/google-service.json
.
Estoy implementando el nuevo Google Cloud Messaging siguiendo las guías de la página Google Developers here
Lo ejecuté y probé con éxito.
Pero mi problema ahora es que tengo diferentes sabores de productos con diferentes applicationId / packageName y diferentes ID de proyecto de Google Cloud Messaging.
google-services.json
debe colocarse en
/app/google-services.json
no en la carpeta de sabores.
¿Hay alguna manera de hacer que la configuración de
google-services.json
diferente para muchos sabores?
ACTUALIZADO:
En cuanto a la configuración de Firebase con variantes de compilación, consulte firebase.googleblog.com/2016/08/… que tiene instrucciones detalladas.
Actualmente estoy usando dos ID de proyecto GCM en el mismo paquete de aplicación. Puse el google-service.json de mi primer proyecto GCM, pero cambio del primero al segundo solo cambiando el SENDER_ID:
String token = instanceID.getToken(SENDER_ID,GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
(En este punto, creo que google-services.json no es obligatorio)
Bueno, me encuentro con el mismo problema y no pude encontrar ninguna solución perfecta. Es solo una solución alternativa. Me pregunto cómo Google no pensó en sabores ... Y espero que propongan pronto una mejor solución.
Qué estoy haciendo:
Tengo dos sabores, en cada uno pongo el correspondiente google-services.json:
src/flavor1/google-services.json
y
src/flavor2/google-services.json
.
Luego, en build gradle, copio el archivo según el sabor al directorio
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
}
Limitación:
deberá cambiar
myFlavor
manualmente
en gradle cada vez que desee ejecutar un sabor diferente (porque está codificado).
Intenté muchas formas de obtener el sabor de construcción actual, como después de
afterEvaluate
cerca ... no podría haber una mejor solución hasta ahora.
Actualización, otra solución: un google-services.json para todos los sabores:
También puede tener diferentes nombres de paquetes para cada sabor y luego, en la
consola de desarrolladores de Google
, no tiene que crear dos aplicaciones diferentes para cada sabor, sino solo dos clientes diferentes en la misma aplicación.
Entonces solo tendrá un
google-services.json
que contenga a sus dos clientes.
Por supuesto, esto depende de cómo esté implementando el backend de sus sabores.
Si no están separados, esta solución no lo ayudará.
Coloque su archivo "google-services.json" en app / src / flavors respectivamente y luego en build.gradle de la aplicación, en Android agregue el siguiente código
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''
}
}
}
}
}
De acuerdo con la respuesta de , puede ponerle un "código de copia" dentro de los sabores de los productos.
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 ''.''
}
}
}
Entonces no tiene que cambiar la configuración manualmente.
De hecho, juste one google-services.json en
MyApp/app/
directorio
MyApp/app/
es bueno, no es necesario un script adicional con
com.google.gms:google-services:3.0.0
.
Pero tenga cuidado de eliminar el archivo
google-services.json
del directorio de aplicaciones
MyApp/app/src/flavor1/res/
para evitar el tipo de error
Execution failed for task '':app:processDebugGoogleServices''. > No matching client found for package
Execution failed for task '':app:processDebugGoogleServices''. > No matching client found for package
El archivo google-services.json no es necesario para recibir notificaciones. Simplemente agregue una variable para cada sabor en su archivo build.gradle:
buildConfigField "String", "GCM_SENDER_ID", "/"111111111111/""
Use esta variable BuildConfig.GCM_SENDER_ID en lugar de getString (R.string.gcm_defaultSenderId) mientras se registra:
instanceID.getToken(BuildConfig.GCM_SENDER_ID, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
El objetivo del complemento de servicios de google es simplificar la integración de las funciones de Google.
Dado que solo genera recursos de Android a partir del archivo google-services.json, la lógica de gradle demasiado complicada niega este punto, creo.
Entonces, si los documentos de Google no dicen qué recursos son necesarios para funciones específicas de Google, sugeriría generar el archivo JSON para cada tipo de compilación / sabor relevante, ver qué recursos genera el complemento y luego poner esos recursos manualmente en sus respectivos directorios src / buildtypeORflavor / res.
Elimine las referencias al complemento de servicios de google y el archivo JSON después de eso, y ya está.
Para obtener información detallada sobre el funcionamiento interno de google-services gradle-plugin, consulte mi otra respuesta:
https://.com/a/33083898/433421
Entonces, si desea copiar programáticamente el archivo
google-services.json
de todas sus variantes en su carpeta raíz.
Cuando cambia a una variante específica, aquí hay una solución para usted
android {
applicationVariants.all { variant ->
copy {
println "Switches to $variant google-services.json"
from "src/$variant"
include "google-services.json"
into "."
}
}
}
Hay una advertencia sobre este enfoque: es necesario tener el archivo
google-service.json
en cada una de las carpetas de variantes. Aquí hay un ejemplo.
Escribió una publicación mediana sobre este tema.
Tuve un problema similar (usando BuildTypes en lugar de Flavours), y lo solucioné así.
Aproveche el sistema de gestión de dependencias de Gradle.
switchToDebug
dos tareas,
switchToDebug
y
switchToRelease
.
Requiere que en cualquier momento se ejecute
assembleRelease
, que
switchToRelease
también se ejecute.
Lo mismo para la depuración.
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
}
EDITAR:
utilice la tarea
processDebugFlavorGoogleServices
/
processReleaseFlavorGoogleServices
para modificarlo en un nivel por sabor.
Estoy usando el archivo google-services.json, creado desde aquí: 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
En la estructura JSON hay una matriz JSON llamada clientes. Si tiene múltiples sabores, simplemente agregue las diferentes propiedades aquí.
{
"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"
}
En mi proyecto, estoy usando el mismo ID de proyecto y cuando agrego el segundo nombre de paquete en la url anterior, google me proporciona un archivo que contiene varios clientes en json-data.
Perdón por los datos JSON compactos. No pude formatearlo correctamente ...
Firebase ahora admite múltiples ID de aplicaciones con un archivo google-services.json.
firebase.googleblog.com/2016/08/… describe en detalle.
Creará un proyecto principal en Firebase que usará para todas sus variantes. Luego, crea aplicaciones de Android separadas en Firebase en ese proyecto para cada ID de aplicación que tenga.
Cuando creó todas sus variantes, puede descargar un google-services.json que admite todos los identificadores de sus aplicaciones. Cuando es relevante ver los datos por separado (es decir, Informes de bloqueo), puede alternar eso con un menú desplegable.
Google incluyó soporte para sabores en la versión 2.0 del complemento de servicios de reproducción.
Desde esta versión del
gradle plugin com.google.gms:google-services:2.0.0-alpha3
Puedes hacerlo
app/src/
flavor1/google-services.json
flavor2/google-services.json
La versión 3.0.0 del complemento busca el archivo json en estas ubicaciones (teniendo en cuenta que tiene un
flavor
sabor1 y una
debug
tipo de compilación):
/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
Esto funcionó para mí incluso usando saborDimensiones. Tengo gratis y pago en una dimensión y Mock & Prod en la otra dimensión. También tengo 3 buildTypes: depuración, lanzamiento y puesta en escena. Así es como se ve en mi proyecto para el sabor FreeProd:
La cantidad de archivos google-services.json dependerá de las características de su proyecto, pero necesitará al menos un archivo json para cada proyecto de Google.
Si desea más detalles sobre lo que hace este complemento con estos archivos json, aquí está: https://github.com/googlesamples/google-services/issues/54#issuecomment-165824720
Enlace a los documentos oficiales: https://developers.google.com/android/guides/google-services-plugin
Publicación de blog con información actualizada: firebase.googleblog.com/2016/08/…
Y vaya aquí para consultar la última versión de este complemento: https://bintray.com/android/android-tools/com.google.gms.google-services/view
He descubierto que el complemento de servicios de google es bastante inútil para proyectos que desean agregar GCM. Solo genera el siguiente archivo que simplemente agrega su ID de proyecto como un recurso de cadena:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!-- Your API key would be on the following line -->
<string name="gcm_defaultSenderId">111111111111</string>
</resources>
Parece que solo lo necesita si copió el código de muestra literalmente directamente de la guía de Cloud Messaging para Android . Aquí está la línea de ejemplo:
String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);
Solución
Si desea poder cambiar los proyectos de API para diferentes tipos de compilación o sabores de productos, puede definir sus propias constantes y elegir la apropiada cuando llame a la 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);
Para sabores de productos
El código anterior funciona para cambiar entre las versiones de depuración y lanzamiento. Para los sabores de productos, definiría diferentes claves API en un archivo fuente de Java y colocaría los archivos en su directorio de sabores de productos correspondiente. Para referencia: Variantes de construcción de Gradle
Hola amigos, también busca el uso del nombre en minúsculas, entonces no aparece este error
Inspirado por la respuesta de @ ahmed_khan_89 arriba. Podemos mantener directamente así en el archivo 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
}
No es necesario ningún script de gradle adicional.
Google comenzó a agregar un nombre de paquete diferente en el nombre de ''android_client_info''. Se ve a continuación en google-services.json
"android_client_info": {
"package_name": "com.android.app.companion.dev"
}
entonces, los siguientes pasos son suficientes para tener una selección diferente de google-services.json.
- Tener 2 sabores
- Agregue un nuevo paquete de desarrollo de sabor a la página de configuración de google analytics y descargue google-services.json.
- Observe que en el nuevo archivo de configuración, los dos identificadores de paquete de su sabor están allí
- Prepara cualquiera de tus sabores.
¡Eso es!..
Según la respuesta de @ ZakTaccardi, y suponiendo que no desea un solo proyecto para ambos sabores, agregue esto al final de su archivo
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
}
Debe tener los archivos
src/staging/google-services.json
y
src/production/google-services.json
.
Reemplace los nombres de sabor por los que usa.
Simplificando lo que dijo @Scotti. Debe crear aplicaciones Múltiples con un nombre de paquete diferente para un Proyecto en particular, dependiendo del sabor del producto.
Suponga que su Proyecto es ABC con diferentes sabores de productos X, Y donde X tiene un nombre de paquete com.x e Y tiene un nombre de paquete com.y luego en la consola de Firebase necesita crear un proyecto ABC en el que necesita crear 2 aplicaciones con los nombres de paquete com.x y com.y. Luego, debe descargar el archivo google-services.json en el que habrá 2 objetos de información del cliente que contendrán esos paquetes y estará listo para comenzar.
Snippet of the json sería algo como esto
{
"client": [
{
"client_info": {
"android_client_info": {
"package_name": "com.x"
}
{
"client_info": {
"android_client_info": {
"package_name": "com.y"
}
]
}
Tenemos un nombre de paquete diferente para las compilaciones de depuración (* .debug), por lo que quería algo que funcione en función del sabor y buildType, sin tener que escribir nada relacionado con el sabor en el patrón de
processDebugFlavorGoogleServices
.
Creé una carpeta llamada "google-services" en cada versión, que contiene tanto la versión de depuración como la versión de lanzamiento del archivo json:
En la sección buildTypes de su archivo gradle, agregue esto:
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
}
}
}
Copiará el archivo json correcto en la raíz del módulo de su aplicación automáticamente cuando cambie la variante de compilación.
Agregue los dos métodos llamados para obtener el sabor actual y el tipo de compilación actual en la raíz de su 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 "";
}
Eso es todo, no tiene que preocuparse por eliminar / agregar / modificar sabores de su archivo gradle, y obtiene la depuración o el lanzamiento google-services.json automáticamente.
Tiene muchos sabores, por lo que significa que tendrá muchas ID de paquete de diferencia, ¿verdad? Entonces, solo vaya a la página donde configura / genera su archivo json y configúrelo para cada nombre de paquete. Todo se agregará al archivo json.
Estoy muy flojo para publicar una foto ahora, pero básicamente:
- vaya a developers.google.com/mobile/add
- seleccione plataforma
- selecciona tu aplicación
- IMPORTANTE : escriba el nombre del paquete de sabor en el campo "nombre del paquete de Android"
- ... continúe obteniendo su archivo de configuración. ¡Descargalo!
Al configurar el archivo, puede ver que Google le muestra la clave API del servidor + ID del remitente. Y es igual para todos los paquetes (sabores)
Al final, solo necesita un archivo json para todos los sabores.
Una pregunta más aquí que debe probar cuando se registra para obtener el Token de registro, verifique si hay diferencia para cada sabor. No lo toco, pero creo que debería ser la diferencia. Demasiado tarde ahora y tengo tanto sueño :) ¡Espero que ayude!
ACTUALIZACIÓN: La siguiente explicación es para un proyecto de Android Studio, con un proyecto de Firebase y diferentes aplicaciones de Firebase dentro de ese proyecto. Si el objetivo es tener diferentes archivos JSON para diferentes aplicaciones de Firebase en diferentes proyectos de Firebase dentro del mismo proyecto de Android Studio, (o si no sabes cuál es la diferencia) firebase.googleblog.com/2016/08/… .
Necesita una aplicación Firebase por ID de aplicación de Android (generalmente, nombre del paquete). Es común tener una ID de aplicación por variante de compilación de Gradle (esto será probable si usa los tipos de compilación de Gradle y los sabores de compilación de Gradle)
A partir de Google Services 3.0 y el uso de Firebase , no es necesario crear diferentes archivos para diferentes sabores. La creación de diferentes archivos para diferentes sabores no puede ser clara o sencilla en caso de que tenga tipos de Productos y Compilaciones que se compongan entre sí.
En el mismo archivo, tendrá todas las configuraciones que necesita para todos sus tipos de compilación y sabores.
En la consola de Firebase, debe agregar una aplicación por nombre de paquete. Imagine que tiene 2 sabores (dev y live) y 2 tipos de compilación (depuración y lanzamiento). Dependiendo de su configuración, pero es probable que tenga 4 nombres de paquete diferentes como:
- com..example (live - release)
- com..example.dev (live - dev)
- com..example.debug (depuración - lanzamiento)
- com..example.dev.debug (debug - dev)
Necesitas 4 aplicaciones de Android diferentes en Firebase Console. (En cada uno, debe agregar el SHA-1 para depurar y en vivo para cada computadora que esté usando)
Cuando descarga el archivo google-services.json, en realidad no importa desde qué aplicación lo descargue, todos ellos contienen la misma información relacionada con todas sus aplicaciones.
Ahora necesita ubicar este archivo en el nivel de aplicación (app /).
Si abre ese archivo, verá que contiene toda la información para todos los nombres de sus paquetes.
Un punto de dolor solía ser el complemento. Para que funcione, debe ubicar el complemento en la parte inferior de su archivo. Entonces esta línea ...
apply plugin: ''com.google.gms.google-services''
... debe estar en la parte inferior del archivo build.gradle de su aplicación.
Para la mayoría de lo dicho aquí, se aplica también a versiones anteriores. Nunca he tenido diferentes archivos para diferentes configuraciones, pero ahora con la consola Firebase es más fácil porque proporcionan un solo archivo con todo lo que necesita para todas sus configuraciones.