google-services.json para diferentes productos


453

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?


Para Maven, hemos implementado algo similar con perfiles de Maven y archivos de propiedades separadas para cada perfil
Sakis kaliakoudas

1
si solo quiere usar sender_id, genere la clave sin ningún nombre de paquete desde la consola de google.
Murtaza Khursheed Hussain

La línea apply plugin: 'com.google.gms.google-services'en el archivo gradle parece poner gcmcadenas en app/build/generated/res/google-services/debug/values/values.xml...
Alexander Farber

La mejor respuesta que he encontrado para esto es sobre esta pregunta
Estel

Asegúrese de leer esto: firebase.googleblog.com/2016/08/... Cubre todas las posibilidades y compensaciones.
Albert Vila Calvo

Respuestas:


509

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:

ingrese la descripción de la imagen aquí

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


13
Esto no funciona para mí por alguna razón: recibo un error de compilación de Gradle, File google-services.json is missing from module root folder. The Google Services Plugin cannot function without it.así que recurriré a copiar el archivo de sabor en la carpeta raíz cada vez a través de un script de compilación.
dodgy_coder

2
Funcionó como un encanto, gracias a Dios por esto. google-services.json y esta nueva forma de usar sus apis parece un paso atrás. No sé cómo se supone que esto sea más fácil.
RED_

140
googl-services.json es una abominación ... ¿cómo es más fácil administrar algún archivo json loco que solo enchufar una clave API y la identificación del remitente? Por favor, google deja de decir tonterías
Greg Ennis

19
La versión más reciente del generador de archivos de configuración coloca múltiples propiedades en el mismo archivo de configuración, solo necesita una en el nivel de la aplicación nuevamente, en lugar de otras separadas en el nivel de sabor. Solo necesita asegurarse de que ambas configuraciones se generen bajo el mismo campo "Nombre de la aplicación".
sroskelley

55
A partir de Android Studio 3.1.4, usar /app/src/flavor1/google-services.json ya no funciona. Los archivos deben ubicarse en /app/src/flavor1/debug/google-services.json y /app/src/flavor1/release/google-services.json.
nurider

71

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 /).

ingrese la descripción de la imagen aquí

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.


Genero el mío desde developers.google.com/mobile/add y solo hay una oportunidad para poner un nombre de paquete. ¿Dónde está el lugar Firebase instalar esto, o lo que hace un vistazo archivo google-services.json como con múltiples sabores
CQM

@CQM He actualizado la respuesta agregando algunos enlaces. Puede consultar la documentación de Firebase y puede generar el archivo JSON en la consola de Firebase como se describe en la respuesta.
Sotti

77
Esta es una muy buena respuesta y debería ser la única respuesta correcta para esta pregunta.
Nando

1
Descubrí esto yo mismo cuando me encontré con el mismo problema, tal como lo describiste anteriormente. Vine aquí para enviar una respuesta para la posteridad solo para descubrir que ya lo has hecho. Con la versión 3.0.0, esta es sin duda la mejor respuesta.
Tash Pemhiwa

66
Tenga en cuenta que esto solo funciona si todos sus sabores están dentro del mismo proyecto de Firebase. Si utilizo varios proyectos (tiendo a mantener el desarrollo y la etapa en un proyecto de Firebase y producir en un proyecto de producto dedicado por separado en una cuenta de Google diferente), necesita la solución descrita por Yair Kukielka. En realidad, el complemento parece admitir una variedad de rutas: durante la compilación, obtendrá una pista sobre dónde fue el complemento buscando el archivo google-services.json: "No se pudo encontrar google-services.json al buscar en [src / prod / debug, src / debug / prod, src / prod, src / debug, src / prodDebug] "
JHH

43

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.


Pero esto funciona para buildTypes, no para sabores según lo publicado por el OP
bryant1410

1
@ bryant1410 si está utilizando un sabor: supongo que en su lugar puede engancharse a la tarea processDebugFlavorGoogleServices.
ZakTaccardi

Creo que debería cambiarlo en su respuesta, ya que la pregunta era sobre sabores, no buildTypes. Creo que también podría dejar esta respuesta como segunda opción
bryant1410

1
@ bryant1410 la lógica es básicamente la misma para un sabor o buildType. deberías poder resolverlo
ZakTaccardi

1
@IgorGanapolsky sí, dos versiones
ZakTaccardi

13

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á.


quieres decir que si los backends están separados, entonces esto no funcionará para ti, creo
ZakTaccardi

todo depende de cómo definas los sabores en ambos lados; cliente y servidor. En mi caso, diferentes nombres de paquetes, diferentes URL de servidor y diferentes bases de datos. Entonces el servidor enviará la notificación al usuario en la base de datos correspondiente. El usuario A tiene token 1 para flavour1 y token2 para flavour2. Si tiene entradas de base de datos diferentes, no tendrá ningún problema.
ahmed_khan_89

He intentado crear tareas que copian y después invocarlos en un proceso de proceso de depuración o lanzamiento en particular y pensar que esto funcionó .wish esta ws publicados anteriormente
humblerookie

1
Usando uno google-services.jsonpara ambos releasey debugfuncionó para mí, como se menciona en su actualización. Creo que esta es la solución más simple si solo está tratando de dividir su debugcompilación, como yo. Como referencia, puede generar el archivo aquí: developers.google.com/mobile/add?platform=android
yuval

12

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.


2
@ZakTaccardi pero la pregunta es para sabores, no para tipos de compilación
bryant1410

1
esta no es una solución tan buena
ZakTaccardi

2
No funciona Esto ejecuta ambos comandos de copia independientemente del sabor de compilación, por lo que la producción json siempre está en el directorio de la aplicación.
Isaac

Funciona para sabores. No es necesario cambiar manualmente las variables en build.gradle.
Vito Valov

9

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


8

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

6

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.


4

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!..


1
No estoy seguro de a qué se refieren exactamente 2) y 3). No puedo encontrar ningún lugar en analytics.google.com donde pueda agregar nombres de paquetes, además de vincular Play Store. El único lugar que he encontrado para descargar json es desde aquí developers.google.com/mobile/add y eso no permite agregar múltiples nombres de paquetes. ¿Funcionará solo agregando manualmente nombres de paquetes a android_client_info?
arberg

1
@arberg Puede agregar varios nombres de paquetes al mismo proyecto y luego descargar el archivo. Consulte aquí: github.com/googlesamples/google-services/issues/54
Christer Nordvik

4

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:

ingrese la descripción de la imagen aquí

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.


4

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.


4

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>

2
Tuve dificultades para hacer coincidir el valor de la clave en el archivo google-services.json que coincide con el equivalente de cadena apropiado, pero luego encontré esto que ayudó: developers.google.com/android/guides/… Publicado en caso de que alguien más tenga el mismo problema.
Saifur Rahman Mohsin

3

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.


3

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


@swimmingtomars Puede que esté aplicando el complemento de servicio de Google innecesariamente. Si usa este método, no puede aplicar el complemento de servicios de google. Consulte la respuesta aceptada si necesita este complemento para un servicio que no sea GCM.
kjones

3

ACTUALIZADO:

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


2

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


No entiendo cómo usar su respuesta, puedo incluir 2 google-service.json. 1 para depuración y otro para lanzamiento
penduDev

2

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

    }

2

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


2

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.imagen variante


1

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!


1

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


0

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)


0

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
}

0

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'
                    }
                }
            }
        }
    }
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.