google-services.json para diferentes productos

Actualización: GCM está en desuso, use FCM

Estoy implementando el nuevo Google Cloud Messaging siguiendo las guías de la página Google Developers aquí.

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. El google-services.jsontiene que ser puesto en el /app/google-services.jsonno a la carpeta sabores.

¿Hay alguna manera de hacer que la google-services.jsonconfiguración sea diferente para muchos sabores?

Google incluyó soporte para sabores en la versión 2.0 del complemento de servicios de reproducción. Desde esta versión de lagradle 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 flavorsabor1 y un tipo de compilación debug):

/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 obtener 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: https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

Y vaya aquí para consultar la última versión de este complemento: https://bintray.com/android/android-tools/com.google.gms.google-services/view

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) mira aquí. .

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 tipos de compilación de Gradle y 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.stackoverflow.example (live - release)
• com.stackoverflow.example.dev (live - dev)
• com.stackoverflow.example.debug (depuración - lanzamiento)
• com.stackoverflow.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.

• Documentos de Firebase
• Firebase Cloud Messaging
• Consola Firebase

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. Creé dos tareas, switchToDebugy switchToRelease. Exigir que assembleReleasese ejecute cualquier momento , que switchToReleasetambién se ejecuta. 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: use processDebugFlavorGoogleServices/ processReleaseFlavorGoogleServicestask para modificarlo a un nivel por sabor.

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 los 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.jsony src/flavor2/google-services.json.

Luego, en build gradle, copio el archivo dependiendo del sabor al app/directorio:

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: tendrá que 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 afterEvaluatecercano ... 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á uno google-services.jsonque 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á.

De acuerdo con la respuesta de ahmed_khan_89 , puede ponerle un "código de copia" dentro de los sabores de 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.

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 = Continuar% 20Adición% 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 los datos json.

Perdón por los datos JSON compactos. No pude formatearlo correctamente ...

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

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 google-servicescarpeta autogenerada para la debugvariante 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_levelbuild.gradle, también puede usar version 3.0.0si está usando la biblioteca app_compact.

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

ahora en app_levelbuild.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 colóquelo dentro de la /app/google-service.jsoncarpeta.

caso 2.) si tiene múltiples build_flavor y tiene diferentes archivos google_services.json dentro app/src/build_flavor/google-service.json .

caso 3.) si tiene múltiples build_flavor y tiene un solo archivo google_services.json puesto dentro app/google-service.json.

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.

1. Tener 2 sabores
2. Agregue un nuevo paquete de desarrollo de sabor a la página de configuración de google analytics y descargue google-services.json.
3. Observe que en el nuevo archivo de configuración, los dos identificadores de paquete de su sabor están allí
4. Prepara cualquiera de tus sabores.

¡Eso es!..

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 el tipo de compilación, 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.

Firebase ahora admite múltiples ID de aplicaciones con un archivo google-services.json.

Esta entrada de blog 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.

Según los documentos de Firebase , también puedes usar recursos de cadena en lugar de google-services.json .

Debido a que este proveedor solo está leyendo recursos con nombres conocidos, otra opción es agregar los recursos de cadena directamente a su aplicación en lugar de usar el complemento de servicios de Google. Puedes hacer esto:

• La eliminación de la google-services complemento de su root build.gradle
• Eliminar el google-services.json de tu proyecto
• Agregar los recursos de cadena directamente
• Eliminar el complemento 'com.google.gms.google-services'de aplicación : desde su aplicación build.gradle

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

Según la respuesta de @ ZakTaccardi, y suponiendo que no desea un solo proyecto para ambos sabores, agregue esto al final de su build.gradlearchivo:

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
}

Necesitas tener los archivos src/staging/google-services.jsony src/production/google-services.json. Reemplace los nombres de sabor por los que usa.

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 al llamar a la 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);

Para sabores de productos

El código anterior funciona para cambiar entre depuración y versiones de 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

ACTUALIZADO:

En cuanto a la configuración de Firebase con variantes de compilación, consulte este blog que tiene instrucciones detalladas.

El objetivo del complemento de servicios de google es simplificar la integración de las funciones de Google.

Como 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://stackoverflow.com/a/33083898/433421

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

    }

De hecho, juste one google-services.json en el MyApp/app/directorio 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.jsondel directorio de la aplicación MyApp/app/src/flavor1/res/para evitar el tipo de errorExecution failed for task ':app:processDebugGoogleServices'. > No matching client found for package

Entonces, si desea copiar programáticamente el google-services.jsonarchivo 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 un google-service.jsonarchivo en cada una de las carpetas de variantes. Aquí hay un ejemplo.

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 https://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!

Cuando configures el archivo, puedes ver que google te 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!

Hola amigos, también busca el uso del nombre en minúsculas, entonces no aparece este error

Actualmente estoy usando dos ID de proyecto GCM en el mismo paquete de aplicación. Puse el google-service.json de mi primer proyecto de 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)

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
}

Coloque su archivo "google-services.json" en app / src / flavors respectivamente y luego en build.gradle de la aplicación, en Android agregue el código siguiente

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