google-servicios.json para diferentes sabores de productos

ACTUALIZACIÓN: La siguiente explicación es para un proyecto de Android Studio, con un proyecto Firebase y diferentes aplicaciones Firebase dentro de ese proyecto. Si el objetivo es tener diferentes archivos JSON para diferentes aplicaciones Firebase en diferentes proyectos 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 Android (generalmente nombre del paquete). Es común tener un ID de aplicación por Variante de compilación de Gradle (esto será probable si usas tipos de compilación de Gradle y sabores de compilación de Gradle)

A partir de Google Services 3.0 y utilizando Firebase no es necesario crear archivos diferentes para diferentes sabores. Crear diferentes archivos para diferentes sabores puede no ser claro o sencillo en caso de que tenga productFlavours y tipos de compilación que se componen entre sí.

En el mismo archivo tendrá todas las configuraciones que necesita todos sus tipos de construcción y sabores.

En la consola Firebase necesita agregar una aplicación por nombre de paquete. Imagine que tiene 2 sabores (dev y live) y 2 tipos de compilación (debug y release). Dependiendo de su configuración, pero es probable que tenga 4 nombres de paquetes diferentes como:

• com.stackoverflow.ejemplo (live - release)
• com.stackoverflow.ejemplo.dev (live - dev)
• com.stackoverflow.ejemplo.depuración (debug - release)
• com.stackoverflow.ejemplo.dev.debug (debug - dev)

Necesitas 4 aplicaciones Android diferentes en la consola Firebase. (En cada uno necesita agregar el SHA-1 para debug y live para cada computadora que está utilizando)

Al descargar los servicios de Google.archivo 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 localizar este archivo en el nivel de aplicación (app/).

Si abre ese archivo verá que si contiene toda la información para todos los nombres de sus paquetes.

Un punto de dolor utilizar para ser el plugin. Para que funcione, debe ubicar el complemento en la parte inferior de su archivo. Así que esta línea..

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

...debe estar en la parte inferior de la compilación de la aplicación.archivo gradle.

Para la mayoría de lo dicho aquí, se aplica a las versiones anteriores también. Nunca he tenido diferentes archivos para diferentes configs, pero ahora con la consola Firebase es más fácil porque proporcionan un solo archivo con todo lo que necesita para todas sus configs.

• Firebase Docs
• Firebase Cloud Messaging
• Consola Firebase

Escribió un post Medium sobre este tema.

Tenía un problema similar (usando buildTypes en lugar de Sabores), y lo arregló así.

Aprovecha el sistema de gestión de dependencias de Gradle. Creé dos tareas, switchToDebug y switchToRelease. Requiere que cada vez que assembleRelease se ejecuta, que switchToRelease también se ejecuta. Lo mismo para depurar.

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: usar processDebugFlavorGoogleServices/processReleaseFlavorGoogleServices tarea para modificarlo en un nivel por tipo.

Bueno, me estoy topando con el mismo problema y no pude obtener ninguna solución perfecta. Es sólo una solución. Me pregunto cómo Google no pensó en sabores...? Y espero que propongan pronto una solución mejor.

Lo que estoy haciendo:

Tengo dos sabores, en cada uno pongo los correspondientes servicios de Google.json: src/flavor1/google-services.json y src/flavor2/google-services.json.

Luego en build gradle copio el archivo dependiendo del tipo 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: usted tendrá que cambiar myFlavor manualmente en gradle cada vez que quieras ejecutar para un tipo diferente (porque está codificado).

Probé muchas maneras de obtener el sabor de compilación actual como afterEvaluate close... no podía conseguir una solución mejor hasta ahora.

Actualización, Otra solución: uno de los servicios de Google.json para todos los sabores:

También puede tener diferentes nombres de paquete para cada sabor y luego en la google developer console no tiene que cree dos aplicaciones diferentes para cada tipo, pero solo dos clientes diferentes en la misma aplicación. Entonces usted tendrá solo uno google-services.json que contiene sus dos clientes. Por supuesto, esto depende de cómo esté implementando el backend de sus sabores. Si no están separados, entonces esta solución no le ayudará.

De acuerdo con la respuesta de ahmed_khan_89, puede poner "copiar código" dentro de los tipos 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.

Servicios de Google.el archivo json no es necesario para recibir notificaciones. Sólo añadir una variable para cada sabor en su construcción.archivo gradle:

buildConfigField "String", "GCM_SENDER_ID", "\"111111111111\""

Utilice esta variable BuildConfig.GCM_SENDER_ID en lugar de getString (R. string.gcm_defaultSenderId) durante el registro:

instanceID.getToken(BuildConfig.GCM_SENDER_ID, GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

Estoy usando los servicios de Google.archivo 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 clients. Si tiene varios 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 project-id y cuando Estoy agregando el segundo nombre del paquete en la url anterior, Google me proporciona un archivo que contiene varios clientes en los datos json.

Lo siento por el compacto JSON-data. No pude formatearlo correctamente...

Tenemos un nombre de paquete diferente para las compilaciones de depuración (*.debug) así que quería algo que funcione basado en sabor y buildType, sin tener que escribir nada relacionado con sabor en el patrón de processDebugFlavorGoogleServices.

He creado una carpeta llamada "google-services" en cada tipo, que contiene tanto la versión de depuración como la versión de lanzamiento del archivo json:

En la sección buildTypes de tu archivo gradle, agrega 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 json correcto archivar en la raíz de tu módulo de aplicación automáticamente cuando cambies de variante de compilación.

Agregue los dos métodos llamados para obtener el tipo actual y el tipo de compilación actual en la raíz de su compilación.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 tienes que preocuparte por eliminar/agregar/modificar sabores de tu archivo gradle, y obtiene la depuración o la versión de google-services.json automáticamente.

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

Esta entrada del blog lo describe en detalle.

Crearás un proyecto padre en Firebase que usarás para todas tus variantes. A continuación, cree aplicaciones Android separadas en Firebase en ese proyecto para cada id de aplicación que tenga.

Cuando haya creado todas sus variantes, puede descargar un google-services.json compatible con todas sus aplicaciones id. Cuando sea relevante ver los datos por separado (es decir, Informes de bloqueos), puede alternar eso con un menú desplegable.

Basado en la respuesta de @ZakTaccardi, y asumiendo 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
}

Necesita tener los archivos src/staging/google-services.json y src/production/google-services.json. Reemplace los nombres de sabor para los que usa.

He encontrado que el complemento google-services 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 ejemplo literalmente directamente de la guía Cloud Messaging for 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 API para diferentes tipos de compilación o tipos de productos, puede definir sus propias constantes y elegir la adecuada 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 compilaciones de depuración y versiones. Para los tipos de productos, definiría diferentes claves API en un archivo de origen java y colocaría los archivos en su directorio de tipos de producto correspondiente. Para referencia: Variantes de compilación de Gradle

No hay necesidad de ningún script gradle adicional.

Google comenzó a agregar un nombre de paquete diferente en el nombre de 'android_client_info'. Se ve como abajo en Google-services.json

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

Por lo tanto, los siguientes pasos son suficientes para tener diferentes servicios de Google.selección json.

1. Tienen 2 sabores
2. Agregue un nuevo paquete de dev flavour a la página de configuración de google analystics y descargue google-services.json.
3. Aviso en el nuevo archivo de configuración, ambos de los identificadores de paquetes de tu sabor están ahí
4. Prepara cualquiera de tus aromas.

¡Eso es todo!..

1.) ¿Qué hace Google-servicios.¿json de verdad?

Sigue esto: https://stackoverflow.com/a/31598587/2382964

2.) Cómo funciona Google-services.archivo json afecta a su proyecto de Android studio?

Sigue esto: https://stackoverflow.com/a/33083898/2382964

Justo en el corto para la segunda url, si se agrega google-services.json en su proyecto debe haber una carpeta autogenerada google-services para la variante debug en este path

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

3.) ¿Qué hacer, para hacerlo?

Agregue la dependencia de google-services en la compilación project_level.gradle, también puedes usar version 3.0.0 si estás usando la biblioteca app_compact.

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

Ahora en la compilación app_level.gradle tienes que añadir en la parte inferior.

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

4.) Dónde poner google-service.archivo json en su estructura.

Caso 1.) si no tienes build_flavor solo ponlo dentro de la carpeta /app/google-service.json.

Caso 2.) si tiene varios build_flavor y tienes diferentes-diferentes google_services.archivos json colocados dentro de app/src/build_flavor/google-service.json.

Caso 3.) si tienes varios build_flavor y tienes un solo google_services.archivo json puesto dentro de app/google-service.json.

El objetivo del complemento de Google-services es simplificar la integración de las funciones de Google.

Ya que solo genera recursos de Android desde los servicios de Google.archivo json, sobre-complicado gradle-lógica niega este punto, creo.

Entonces, si los documentos de Google no dicen qué recursos se necesitan para características específicas de Google, sugeriría generar el archivo JSON para cada tipo de compilación/sabor relevante, ver qué recursos se generan por el complemento y luego colocar esos recursos manualmente en sus respectivos directorios src/buildtypeORflavor / res.

Elimine las referencias al complemento de Google-services y al archivo JSON después de eso, y habrá terminado.

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 @Scotti dijo. Es necesario crear varias aplicaciones con un nombre de paquete diferente para un proyecto en particular, dependiendo del tipo de producto.

Supongamos que su Proyecto es ABC con diferentes tipos 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 firebase necesita crear un proyecto ABC en el que necesita crear 2 aplicaciones con los nombres de paquete com.x y com.y. A continuación, es necesario descargar los servicios de Google.archivo json en que habrá 2 objetos de información del cliente que contendrán esos pacakges y usted estará listo.

El fragmento del 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"
        }
      ]

    }

Tiene muchos sabores, por lo que significa que tendrá muchos id de paquete de diferencia, ¿verdad? Por lo tanto, simplemente vaya a la página donde configura/genera su archivo json y config para cada nombre de paquete. Todo se agregará al archivo json.

Soy muy perezoso para publicar la foto ahora, pero básicamente:

• vaya a https://developers.google.com/mobile/add
• seleccione la plataforma
• seleccione su aplicación
• IMPORTANTE: escriba el nombre de su paquete de sabor en el campo "paquete android nombre"
• ... continúe para obtener su archivo de configuración. ¡Descárgalo!

Al configurar el archivo, puede ver que Google le muestra la Clave de API del servidor + ID del remitente. Y es lo mismo para todos los paquetes (sabores)

Al final, solo necesita un solo archivo json para todos los sabores.

Una pregunta más aquí que usted tiene que probar cuando se registra para obtener Token de registro, comprobar si es la diferencia para cada sabor. No lo toco, pero creo que debería ser diferente. Demasiado tarde ahora y yo tan soñoliento:) Espero que ayude!

Hey Amigos también busca nombre use solo minúsculas entonces u no obtener este error

ACTUALIZADO:

En términos de configuración de Firebase con variantes de compilación, consulte este blog que tiene instrucciones detalladas.

Actualmente estoy usando dos ID de proyecto de GCM en el mismo paquete de aplicación. Puse el servicio de Google.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 los servicios de Google.json no es obligatorio)

Inspirado por @ahmed_khan_89 respuesta anterior. 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 "google-services.archivo json " en app / src / flavors respectivamente luego en construcción.gradle de la aplicación, bajo Android agregar código debajo

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 hecho, solo un Google-servicios.json en el directorio MyApp/app/ es bueno, no hay necesidad de script adicional con com.google.gms:google-services:3.0.0. Pero tenga cuidado de eliminar el archivo google-services.json del directorio de la aplicación MyApp/app/src/flavor1/res/ para evitar el tipo de error Execution failed for task ':app:processDebugGoogleServices'. > No matching client found for package