google-services.json para diferentes productFlavors

453

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?

gentra
fonte
Para Maven, temos implementado algo semelhante usando perfis Maven e arquivos de propriedade separadas para cada perfil
sakis kaliakoudas
1
se você quiser apenas usar o sender_id, gere a chave sem nenhum nome de pacote no console do Google.
Murtaza Khursheed Hussain
A linha apply plugin: 'com.google.gms.google-services'no arquivo Gradle parece colocar gcmcordas em app/build/generated/res/google-services/debug/values/values.xml...
Alexander Farber
A melhor resposta que eu encontrei para isso é sobre esta questão
Estel
Não deixe de ler o seguinte: firebase.googleblog.com/2016/08/… Ele cobre todas as possibilidades e compensações.
Albert Vila Calvo

Respostas:

509

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:

insira a descrição da imagem aqui

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

Yair Kukielka
fonte
13
Por algum motivo, isso não está funcionando para mim - recebo um erro de compilação gradle - File google-services.json is missing from module root folder. The Google Services Plugin cannot function without it.por isso vou copiar o arquivo de sabor na pasta raiz todas as vezes por meio de um script de compilação.
Dodgy_coder 03/03
2
Funcionou como um encanto, graças a Deus por isso. google-services.json e toda essa nova maneira de usar suas APIs parece um passo atrás. Não sei como isso deveria ser mais fácil.
RED_
140
googl-services.json é uma abominação ... como é mais fácil gerenciar um arquivo json louco do que simplesmente conectar uma chave de API e um ID de remetente? Por favor google parar o absurdo
Greg Ennis
19
A versão mais recente do gerador do arquivo de configuração coloca várias propriedades no mesmo arquivo de configuração, precisando apenas de uma no nível do aplicativo novamente, em vez de separadas no nível de sabor. Você só precisa garantir que as duas configurações sejam geradas no mesmo campo "Nome do aplicativo".
Sroskelley 14/05
5
No Android Studio 3.1.4, o uso de /app/src/flavor1/google-services.json não funciona mais. Os arquivos devem estar localizados em /app/src/flavor1/debug/google-services.json e /app/src/flavor1/release/google-services.json.
Nurider 26/09/18
71

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

insira a descrição da imagem aqui

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.

Sotti
fonte
Eu gero o meu a partir de developers.google.com/mobile/add e existe apenas uma oportunidade para colocar o nome de um pacote. Onde é o lugar Firebase para configurá-lo, ou o que faz um olhar arquivo google-services.json como com vários sabores
CQM
@CQM Atualizei a resposta adicionando alguns links. Você pode verificar a documentação do Firebase e gerar o arquivo JSON no console do Firebase, conforme descrito na resposta.
Sotti 28/07
7
Essa é uma resposta muito boa e deve ser a única resposta correta para essa pergunta.
Nando
1
Eu mesmo descobri isso quando me deparei com o mesmo problema, assim como você o descreveu acima. Eu vim aqui para enviar uma resposta para a posteridade apenas para descobrir que você já a fez. Com a versão 3.0.0, essa é certamente a melhor resposta.
Tash Pemhiwa
6
Observe que isso só funciona se todos os seus sabores estiverem no mesmo projeto da base de firmas. Se estiver usando vários projetos (eu tendem a manter o desenvolvedor e o estágio em um projeto da base de firmas e produzir em um projeto de produtos dedicado separado em uma conta do google diferente), você precisará da solução descrita por Yair Kukielka. Na verdade, o plug-in parece oferecer suporte a vários caminhos - durante a compilação, você terá uma dica sobre onde o plug-in foi procurar o arquivo google-services.json: "Não foi possível encontrar o google-services.json enquanto procurava em [src / prod / debug, src / debug / prod, src / prod, src / debug, src / prodDebug] "
JHH
43

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.

ZakTaccardi
fonte
Mas isso funciona para buildTypes, não para sabores como publicado pelo OP
bryant1410
1
@ bryant1410 se você estiver usando um sabor - acho que você pode se conectar à tarefa processDebugFlavorGoogleServices.
ZakTaccardi
Eu acho que você deveria alterá-lo em sua resposta, pois a pergunta era sobre sabores, não buildTypes. Eu acho que você também pode deixar esta resposta como segunda opção
bryant1410
1
@ bryant1410 a lógica é basicamente a mesma para um sabor ou buildType. você deve ser capaz de descobrir isso?
ZakTaccardi 4/15
1
@IgorGanapolsky sim, duas versões
ZakTaccardi
13

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

ahmed_khan_89
fonte
Quer dizer que se os backends são separados, então isso não vai funcionar para você, eu acredito
ZakTaccardi
tudo depende de como sua definição dos sabores dos dois lados; cliente e servidor. No meu caso, nomes de pacotes diferentes, URLs de servidor diferentes e bancos de dados diferentes. Portanto, o servidor enviará a notificação ao usuário no banco de dados correspondente. O usuário A possui o token 1 para o sabor1 e o token2 para o sabor2. Se você tiver entradas diferentes no banco de dados, não terá nenhum problema.
precisa saber é o seguinte
Eu tentei criar tarefas que copiar e, em seguida, invocando-los em um determinado processo de processo de depuração ou liberação e acho que isso funcionou .Wish este ws postei anteriormente
humblerookie
1
Usando um google-services.jsonpara ambos releasee debugfuncionou para mim, como mencionado na sua atualização. Eu acho que essa é a solução mais simples se você estiver apenas tentando dividir sua debugcompilação, como eu. Para referência, você pode gerar o arquivo aqui: developers.google.com/mobile/add?platform=android
yuval
12

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.

Kros CS Huang
fonte
2
@ZakTaccardi mas a questão é de sabores, não para tipos de compilação
bryant1410
1
esta não é uma solução tão boa
ZakTaccardi
2
Não funciona Isso executa os dois comandos de cópia, independentemente do tipo de construção, portanto, o json de produção está sempre no diretório do aplicativo.
Isaac
Funciona para sabores. Não há necessidade de alternar manualmente variáveis ​​no build.gradle.
Vito Valov
9

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

Mark Martinsson
fonte
8

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);
divonas
fonte
6

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.

Tushar Pandey
fonte
4

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

Rames Palanisamy
fonte
1
Não sei ao que exatamente 2) e 3) se referem. Não consigo encontrar nenhum lugar no analytics.google.com onde posso adicionar nomes de pacotes, além de vincular a play store. O único local que encontrei para baixar o json é a partir daqui developers.google.com/mobile/add e isso não permite adicionar vários nomes de pacotes. Funcionará apenas adicionando manualmente nomes de pacotes ao android_client_info?
Arberg #
1
@arberg Você pode adicionar vários nomes de pacotes ao mesmo projeto e fazer o download do arquivo. Verifique aqui: github.com/googlesamples/google-services/issues/54
Christer Nordvik em
4

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:

insira a descrição da imagem aqui

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.

FallasB
fonte
4

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.

bMcNees
fonte
4

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>
David P
fonte
2
Tive dificuldade em corresponder o valor de qual chave no arquivo google-services.json corresponde ao equivalente de sequência apropriado, mas achei isso que ajudou: developers.google.com/android/guides/… Publicado caso outra pessoa tenha o mesmo problema.
Saifur Rahman Mohsin
3

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.

bryant1410
fonte
3

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

kjones
fonte
@swimmingtomars Você pode estar aplicando o plugin do google-service desnecessariamente. Se você usar esse método, não poderá aplicar o plug-in google-services. Veja a resposta aceita se você precisar deste plugin para outro serviço que não o GCM.
kjones
3

ATUALIZADA:

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

KayAnn
fonte
2

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

arne.jans
fonte
Não entendo como, usando sua resposta, posso incluir 2 google-service.json. 1 para depuração e outra para a liberação
penduDev
2

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

    }
Sagar Devanga
fonte
2

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

gigeos
fonte
2

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

pratham kesarkar
fonte
1

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!

Lạng Hoàng
fonte
1

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

Divyesh Jani
fonte
0

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)

ariostoi
fonte
0

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
}
Noundla Sandeep
fonte
0

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'
                    }
                }
            }
        }
    }
Sameer Khader
fonte