google-services.json para diferentes productFlavors

Atualização: o GCM está obsoleto, use o FCM

Estou implementando o novo Google Cloud Messaging seguindo os guias da página Google Developers aqui

Eu executei e testei com sucesso. Mas o meu problema agora é que tenho diferentes tipos de produtos com applicationId / packageName e ID do projeto diferentes do Google Cloud Messaging. Eles google-services.jsondevem ser colocados na /app/google-services.jsonpasta not the flavors.

Existe alguma maneira de tornar a google-services.jsonconfiguração diferente para muitos sabores?

O Google incluiu suporte para sabores na versão 2.0 do plug-in do play services. Desde esta versão dogradle plugin com.google.gms:google-services:2.0.0-alpha3

você consegue fazer isso

app/src/
    flavor1/google-services.json
    flavor2/google-services.json

A versão 3.0.0 do plug-in procura pelo arquivo json nesses locais (considerando que você possui um flavorsabor1 e um tipo de construção debug):

/app/src/debug/google-services.json
/app/src/debug/flavor1/google-services.json
/app/google-services.json

Isso funcionou para mim mesmo usando flavorDimensions. Tenho grátis e pago em uma dimensão e Mock & Prod na outra dimensão. Eu também tenho 3 buildTypes: depuração, lançamento e preparação. É assim que parece no meu projeto o sabor do FreeProd:

Quantos arquivos google-services.json dependerão das características do seu projeto, mas você precisará de pelo menos um arquivo json para cada projeto do Google.

Se você quiser obter mais detalhes sobre o que esse plug-in faz com esses arquivos json, aqui está: https://github.com/googlesamples/google-services/issues/54#issuecomment-165824720

Link para os documentos oficiais: https://developers.google.com/android/guides/google-services-plugin

Postagem em blog com informações atualizadas: https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

E clique aqui para verificar a versão mais recente deste plug-in: https://bintray.com/android/android-tools/com.google.gms.google-services/view

ATUALIZAÇÃO: A explicação a seguir é para um projeto do Android Studio, com um projeto Firebase e diferentes aplicativos Firebase dentro desse projeto. Se o objetivo é ter arquivos JSON diferentes para diferentes aplicativos Firebase em diferentes projetos Firebase dentro do mesmo projeto do Android Studio, (ou se você não sabe qual é a diferença), veja aqui. .

Você precisa de um aplicativo Firebase por ID do aplicativo Android (geralmente o nome do pacote). É comum ter um ID do aplicativo por variante de compilação Gradle (isso provavelmente ocorrerá se você usar os tipos de compilação Gradle e os sabores de compilação Gradle)

No Google Services 3.0 e no Firebase , não é necessário criar arquivos diferentes para diferentes sabores. A criação de arquivos diferentes para diferentes sabores pode não ser clara ou direta, caso você tenha tipos productFlavours e Build que se compõem.

No mesmo arquivo, você terá todas as configurações necessárias para todos os seus tipos e sabores de build.

No console do Firebase, você precisa adicionar um aplicativo por nome do pacote. Imagine que você tem 2 tipos (dev e live) e 2 tipos de build (depuração e lançamento). Dependendo da sua configuração, mas é provável que você tenha 4 nomes de pacotes diferentes, como:

• com.stackoverflow.example (versão ao vivo)
• com.stackoverflow.example.dev (live - dev)
• com.stackoverflow.example.debug (depuração - lançamento)
• com.stackoverflow.example.dev.debug (depuração - dev)

Você precisa de quatro aplicativos Android diferentes no console do Firebase. (Em cada um, você precisa adicionar o SHA-1 para depuração e viver para cada computador que estiver usando)

Quando você baixa o arquivo google-services.json, na verdade, não importa em qual aplicativo você o baixa, todos eles contêm as mesmas informações relacionadas a todos os seus aplicativos.

Agora você precisa localizar este arquivo no nível do aplicativo (app /).

Se você abrir esse arquivo, verá que se contém todas as informações para todos os nomes de pacotes.

Um ponto problemático costuma ser o plugin. Para fazê-lo funcionar, você precisa localizar o plug-in na parte inferior do seu arquivo. Então esta linha ..

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

... precisa estar na parte inferior do arquivo build.gradle do aplicativo.

Para a maioria das opções mencionadas aqui, isso também se aplica às versões anteriores. Eu nunca tive arquivos diferentes para configurações diferentes, mas agora com o console do Firebase é mais fácil porque eles fornecem um único arquivo com tudo o que você precisa para todas as suas configurações.

• Documentos do Firebase
• Firebase Cloud Messaging
• Firebase Console

Escreveu uma postagem média sobre esse problema.

Teve um problema semelhante (usando BuildTypes em vez de Flavors) e o corrigiu assim.

Aproveite o sistema de gerenciamento de dependências da Gradle. Eu criei duas tarefas switchToDebuge switchToRelease. Exija que a qualquer momento assembleReleaseseja executada, que switchToReleasetambém seja executada. O mesmo para depuração.

def appModuleRootFolder = '.'
def srcDir = 'src'
def googleServicesJson = 'google-services.json'

task switchToDebug(type: Copy) {
    def buildType = 'debug'
    description = 'Switches to DEBUG google-services.json'
    from "${srcDir}/${buildType}"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

task switchToRelease(type: Copy) {
    def buildType = 'release'
    description = 'Switches to RELEASE google-services.json'
    from "${srcDir}/${buildType}/"
    include "$googleServicesJson"
    into "$appModuleRootFolder"
}

afterEvaluate {
    processDebugGoogleServices.dependsOn switchToDebug
    processReleaseGoogleServices.dependsOn switchToRelease
}

EDIT: use processDebugFlavorGoogleServices/ processReleaseFlavorGoogleServicestask para modificá-lo em um nível por sabor.

Bem, estou enfrentando o mesmo problema e não consegui nenhuma solução perfeita. É apenas uma solução alternativa. Gostaria de saber como o Google não pensou em sabores ...? E espero que em breve eles proponham uma solução melhor.

O que estou fazendo:

Eu tenho dois sabores, em cada um eu coloco o correspondente google-services.json: src/flavor1/google-services.jsone src/flavor2/google-services.json.

Em seguida, no build gradle, copio o arquivo, dependendo do sabor do app/diretório:

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
}

Limitação: você terá que mudar myFlavor manualmente em gradle toda vez que quiser executar um sabor diferente (porque é codificado).

Tentei várias maneiras de obter o sabor atual da compilação como afterEvaluatepróximo ... não consegui nenhuma solução melhor até agora.

Atualização, outra solução: um google-services.json para todos os tipos:

Você também pode ter nomes de pacotes diferentes para cada sabor e, no console do desenvolvedor do Google , não precisa criar dois aplicativos diferentes para cada sabor, mas apenas dois clientes diferentes no mesmo aplicativo. Então você terá apenas um google-services.jsonque contenha seus dois clientes. Obviamente, isso depende de como você está implementando o back-end de seus sabores. Se não estiverem separados, esta solução não o ajudará.

De acordo com a resposta de ahmed_khan_89 , você pode colocar seu "código de cópia" dentro dos sabores do produto.

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

Então você não precisa alterar as configurações manualmente.

Estou usando o arquivo google-services.json, criado a partir daqui: https://developers.google.com/mobile/add?platform=android&cntapi=gcm&cnturl=https:%2F%2Fdevelopers.google.com%2Fcloud-messaging % 2Fandroid% 2Fclient & cntlbl = Continue% 20Adicionando% 20GCM% 20Support &% 3Fconfigured% 3Dtrue

Na estrutura JSON, há uma matriz JSON chamada clientes. Se você tiver vários sabores, basta adicionar as diferentes propriedades aqui.

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

No meu projeto, estou usando o mesmo ID do projeto e, quando adiciono o segundo nome do pacote no URL acima, o google fornece um arquivo que contém vários clientes nos dados json.

Desculpe pelos dados JSON compactos. Não consegui formatá-lo corretamente ...

O arquivo google-services.json é desnecessário para receber notificações. Basta adicionar uma variável para cada sabor no seu arquivo build.gradle:

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

Use esta variável BuildConfig.GCM_SENDER_ID em vez de getString (R.string.gcm_defaultSenderId) ao registrar:

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

1.) O que o google-services.json realmente faz?

Siga este: https://stackoverflow.com/a/31598587/2382964

2.) Como o arquivo google-services.json afeta o seu projeto do android studio?

Siga este: https://stackoverflow.com/a/33083898/2382964

para resumir o segundo URL, se você adicionar google-services.json no seu projeto, deve haver uma google-servicespasta gerada automaticamente para a debugvariante nesse caminho

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

3.) O que fazer, para fazê-lo?

adicionar dependência de serviços do google em project_levelbuild.gradle, você também pode usar version 3.0.0se estiver usando a biblioteca app_compact.

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

agora em app_levelbuild.gradle você deve adicionar na parte inferior.

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

4.) Onde colocar o arquivo google-service.json em sua estrutura.

caso 1.) se você não tiver o build_flavor, basta colocá-lo dentro da /app/google-service.jsonpasta.

caso 2.) se você tiver vários build_flavor e tiver diferentes arquivos google_services.json diferentes app/src/build_flavor/google-service.json.

caso 3.) se você tiver vários build_flavor e tiver um único arquivo google_services.json colocado dentro app/google-service.json.

Não há necessidade de nenhum script gradle adicional.

O Google começou a adicionar um nome de pacote diferente no nome de 'android_client_info'. Parece abaixo no google-services.json

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

portanto, as etapas a seguir são suficientes para ter uma seleção diferente do google-services.json.

1. Tenha 2 sabores
2. Adicione um novo pacote do dev flavour à página de configuração do google analystics e faça o download do google-services.json.
3. Observe no novo arquivo de configuração que os dois IDs de pacote do seu sabor estão lá
4. Prepare qualquer um dos seus sabores.

É isso!..

Como temos um nome de pacote diferente para compilações de depuração (* .debug), eu queria algo que funcionasse com base no sabor e no buildType, sem precisar escrever nada relacionado ao sabor no padrão de processDebugFlavorGoogleServices.

Criei uma pasta chamada "google-services" em cada tipo, contendo a versão de depuração e a versão do arquivo json:

Na seção buildTypes do seu arquivo gradle, adicione isto:

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

Ele copiará o arquivo json correto na raiz do seu módulo de aplicativo automaticamente quando você alternar a variante de compilação.

Adicione os dois métodos chamados para obter o sabor atual e o tipo de construção atual na raiz do seu 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 "";
}

É isso aí, você não precisa se preocupar em remover / adicionar / modificar sabores do seu arquivo gradle, e ele obtém a depuração ou a liberação google-services.json automaticamente.

O Firebase agora suporta vários IDs de aplicativos com um arquivo google-services.json.

Esta postagem do blog descreve em detalhes.

Você criará um projeto pai no Firebase que será usado para todas as suas variantes. Você cria aplicativos Android separados no Firebase nesse projeto para cada ID de aplicativo que você possui.

Quando você criou todas as suas variantes, pode fazer o download de um google-services.json que suporta todos os IDs de seus aplicativos. Quando for relevante ver os dados separadamente (por exemplo, Relatórios de falhas), você pode alterná-los com uma lista suspensa.

De acordo com os documentos do Firebase, você também pode usar recursos de string em vez do google-services.json .

Como esse provedor está apenas lendo recursos com nomes conhecidos, outra opção é adicionar os recursos de string diretamente ao seu aplicativo, em vez de usar o plug-in de classificação dos serviços do Google. Você pode fazer isso:

• Removendo o google-servicesplugin do seu root build.gradle
• Excluindo o google-services.jsondo seu projeto
• Incluindo os recursos de sequência diretamente
• Excluindo o plug-in de aplicação: 'com.google.gms.google-services'do seu aplicativo build.gradle

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

Com base na resposta de @ ZakTaccardi, e assumindo que você não deseja um único projeto para ambos os tipos, adicione-o ao final do seu build.gradlearquivo:

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
}

Você precisa ter os arquivos src/staging/google-services.jsone src/production/google-services.json. Substitua os nomes dos sabores pelos que você usa.

Descobri que o plug - in google-services é bastante inútil para projetos que desejam adicionar o GCM. Ele gera apenas o seguinte arquivo, que simplesmente adiciona o ID do seu projeto como um recurso de string:

<?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 você só precisa dele se tiver copiado o código de amostra literalmente diretamente do guia Cloud Messaging para Android . Aqui está a linha de exemplo:

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

Solução

Se você deseja alternar projetos de API para diferentes tipos de construção ou tipos de produtos, basta definir suas próprias constantes e escolher a apropriada ao chamar a 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 produtos

O código acima funciona para alternar entre compilações de depuração e lançamento. Para os sabores do produto, você define diferentes chaves de API em um arquivo de origem java e coloca os arquivos no diretório de sabores do produto correspondente. Para referência: Gradle Build Variants

ATUALIZADA:

Em termos de configuração do Firebase com variantes de compilação, consulte este blog que possui instruções detalhadas.

O objetivo do plug-in de serviços do Google é simplificar a integração dos recursos do Google.

Como ele gera apenas recursos do Android a partir do arquivo google-services.json, a lógica gradle complicada demais nega esse ponto, eu acho.

Portanto, se os documentos do Google não disserem quais recursos são necessários para os recursos específicos do Google, sugiro gerar o arquivo JSON para cada tipo / tipo de construção relevante, veja quais recursos são gerados pelo plug-in e os coloque manualmente em seus respectivos diretórios src / buildtypeORflavor / res.

Exclua as referências ao plug-in google-services e ao arquivo JSON depois disso e pronto.

Para informações detalhadas sobre o funcionamento interno do google-services gradle-plugin, veja minha outra resposta:

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

Simplificando o que o @Scotti disse. Você precisa criar aplicativos Múltiplos com nome de pacote diferente para um projeto específico, dependendo do sabor do produto.

Suponha que seu projeto seja ABC com diferentes sabores de produtos X, Y, em que X possui um nome de pacote com.x e Y possui um nome de pacote com.y, no console da base de firmas, é necessário criar um projeto ABC no qual é necessário criar 2 aplicativos com os nomes dos pacotes com.x e com.y. Então você precisa fazer o download do arquivo google-services.json no qual haverá 2 objetos de informações do cliente que conterão esses pacakges e você estará pronto para prosseguir.

Fragmento do json seria algo como isto

{
  "client": [
    {
      "client_info": {
        "android_client_info": {
          "package_name": "com.x"
        }

    {
      "client_info": {
        "android_client_info": {
          "package_name": "com.y"
        }
      ]

    }

De fato, apenas um google-services.json no MyApp/app/diretório é bom, sem a necessidade de scripts adicionais com.google.gms:google-services:3.0.0. Mas tenha cuidado para excluir o arquivo google-services.jsondo diretório do aplicativo MyApp/app/src/flavor1/res/para evitar o tipo de erroExecution failed for task ':app:processDebugGoogleServices'. > No matching client found for package

Portanto, se você deseja copiar programaticamente o google-services.jsonarquivo de todas as suas variantes para a pasta raiz. Quando você muda para uma variante específica, eis uma solução para você

android {
  applicationVariants.all { variant ->
    copy {
        println "Switches to $variant google-services.json"
        from "src/$variant"
        include "google-services.json"
        into "."
    }
  }
}

Há uma ressalva nessa abordagem: você precisa ter um google-service.jsonarquivo em cada uma das pastas de variantes. Aqui está um exemplo.

Você tem muitos sabores, então isso significa que você terá muitos IDs de pacotes diferentes, certo? Então, basta ir para a página onde você configura / gera seu arquivo json e config para cada nome de pacote. Tudo isso será adicionado ao arquivo json.

Estou com muita preguiça de postar fotos agora, mas basicamente:

• acesse https://developers.google.com/mobile/add
• selecionar plataforma
• selecione seu aplicativo
• IMPORTANTE : digite o nome do seu pacote de sabores no campo "nome do pacote do Android"
• ... continue obtendo seu arquivo de configuração. Baixe!

Ao configurar o arquivo, você pode ver que o google mostra a chave da API do servidor + o ID do remetente. E é o mesmo para todos os pacotes (sabores)

No final, você só precisa de apenas um arquivo json para todos os tipos.

Mais uma pergunta aqui que você deve testar ao se registrar para obter o token de registro, verifique se há diferença para cada sabor. Eu não toco, mas acho que deve ser a diferença. Tarde demais agora e eu estou com tanto sono :) Espero que ajude!

Ei, amigos também procura pelo nome, use apenas minúsculas e você não recebe esse erro

Atualmente, estou usando dois IDs de projeto do GCM no mesmo pacote de aplicativos. Coloquei o google-service.json do meu primeiro projeto do GCM, mas alterno do primeiro para o segundo, alterando apenas o SENDER_ID:

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

(Nesse ponto, acho que o google-services.json não é obrigatório)

Inspirado pela resposta ahmed_khan_89 acima. Podemos manter isso diretamente no arquivo 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 o arquivo "google-services.json" em app / src / flavors respectivamente, em seguida, em build.gradle of app, em android, adicione o código abaixo

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