google-services.json per diversi gusti di prodotto

Aggiornamento: GCM è obsoleto, utilizzare FCM

Sto implementando il nuovo Google Cloud Messaging seguendo le guide dalla pagina degli sviluppatori di Google qui

Ho eseguito e testato con successo. Ma il mio problema ora è che ho diverse varianti di prodotto con differenti applicationId / packageName e diverso ID progetto Google Cloud Messaging. Il google-services.jsondevono essere messe a /app/google-services.jsonnon la cartella sapori.

Esiste un modo per rendere la google-services.jsonconfigurazione diversa per molti gusti?

Google ha incluso il supporto per i sapori nella versione 2.0 del plug-in dei servizi di riproduzione. Da questa versione delgradle plugin com.google.gms:google-services:2.0.0-alpha3

Puoi farlo

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

La versione 3.0.0 del plug-in cerca il file json in queste posizioni (considerando che hai un flavorsapore1 e un tipo di build debug):

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

Questo ha funzionato anche per me usando flavidimensioni. Ho gratis e pagato in una dimensione e Mock & Prod nell'altra dimensione. Ho anche 3 buildTypes: debug, rilascio e gestione temporanea. Ecco come appare nel mio progetto il sapore FreeProd:

Quanti file google-services.json dipenderanno dalle caratteristiche del tuo progetto, ma avrai bisogno di almeno un file json per ogni progetto Google.

Se vuoi maggiori dettagli su cosa fa questo plugin con questi file json, eccolo qui: https://github.com/googlesamples/google-services/issues/54#issuecomment-165824720

Link ai documenti ufficiali: https://developers.google.com/android/guides/google-services-plugin

Post di blog con informazioni aggiornate: https://firebase.googleblog.com/2016/08/organizing-your-firebase-enabled-android-app-builds.html

E vai qui per controllare l'ultima versione di questo plugin: https://bintray.com/android/android-tools/com.google.gms.google-services/view

AGGIORNAMENTO: la seguente spiegazione riguarda un progetto Android Studio, con un progetto Firebase e diverse app Firebase all'interno di quel progetto. Se l'obiettivo è avere file JSON diversi per diverse app Firebase in diversi progetti Firebase all'interno dello stesso progetto Android Studio, (o se non sai qual è la differenza) guarda qui. .

È necessaria un'app Firebase per ID applicazione Android (in genere nome del pacchetto). È comune avere un ID applicazione per variante di build Gradle (questo sarà probabilmente se si utilizzano tipi di build Gradle e sapori di build Gradle)

A partire da Google Services 3.0 e l'utilizzo di Firebase non è necessario creare file diversi per gusti diversi. La creazione di file diversi per gusti diversi può non essere chiara o semplice nel caso in cui tu abbia ProductFlavours e tipi di Build che si compongono l'uno con l'altro.

Nello stesso file avrai tutte le configurazioni di cui hai bisogno per tutti i tuoi tipi e gusti di build.

Nella console di Firebase è necessario aggiungere un'app per nome del pacchetto. Immagina di avere 2 gusti (dev e live) e 2 tipi di build (debug e rilascio). A seconda della configurazione, ma è probabile che tu abbia 4 nomi di pacchetti diversi come:

• com.stackoverflow.example (live - versione)
• com.stackoverflow.example.dev (live - dev)
• com.stackoverflow.example.debug (debug - versione)
• com.stackoverflow.example.dev.debug (debug - dev)

Sono necessarie 4 diverse app Android nella Firebase Console. (Su ognuno è necessario aggiungere SHA-1 per il debug e vivere per ogni computer che si sta utilizzando)

Quando scarichi il file google-services.json, in realtà non importa da quale app lo scarichi, tutti contengono le stesse informazioni relative a tutte le tue app.

Ora è necessario individuare questo file a livello di app (app /).

Se apri quel file, vedrai che contiene tutte le informazioni per tutti i nomi dei pacchetti.

Un punto dolente per essere il plugin. Per farlo funzionare è necessario individuare il plugin nella parte inferiore del file. Quindi questa linea ..

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

... deve trovarsi nella parte inferiore del file build.gradle dell'app.

Per la maggior parte di quanto detto qui, si applica anche alle versioni precedenti. Non ho mai avuto file diversi per configurazioni diverse, ma ora con la console Firebase è più facile perché forniscono un singolo file con tutto il necessario per tutte le configurazioni.

• Firebase Docs
• Firebase Cloud Messaging
• Console Firebase

Ha scritto un post medio su questo problema.

Aveva un problema simile (usando BuildTypes invece di Flavours) e risolto in questo modo.

Approfitta del sistema di gestione delle dipendenze di Gradle. Ho creato due attività switchToDebuge switchToRelease. Richiede che ogni volta che assembleReleaseviene eseguito, anche quello switchToReleasevenga eseguito. Lo stesso vale per il debug.

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: usa processDebugFlavorGoogleServices/ processReleaseFlavorGoogleServicestask per modificarlo a livello di sapore.

Bene, sto riscontrando lo stesso problema e non sono riuscito a trovare una soluzione perfetta. È solo una soluzione alternativa. Mi chiedo come Google non abbia pensato ai sapori ...? E spero che presto proporranno una soluzione migliore.

Cosa sto facendo:

Ho due gusti, in ognuno ho messo il corrispondente google-services.json: src/flavor1/google-services.jsonesrc/flavor2/google-services.json .

Quindi in build Gradle copio il file a seconda del sapore nella app/directory:

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
}

Limitazione: dovrai cambiare myFlavor manualmente in pendenza ogni volta che vuoi correre per un sapore diverso (perché è codificato).

Ho provato molti modi per ottenere il sapore della build attuale afterEvaluate vicino ... non ho potuto trovare una soluzione migliore fino ad ora.

Aggiornamento, un'altra soluzione: un google-services.json per tutti i gusti:

Puoi anche avere nomi di pacchetti diversi per ogni sapore e quindi nella console per gli sviluppatori di Google non devi creare due app diverse per ogni sapore, ma solo due client diversi nella stessa app. Quindi ne avrai solo uno google-services.jsonche contiene entrambi i tuoi clienti. Naturalmente, questo dipende da come stai implementando il backend dei tuoi gusti. Se non sono separati, questa soluzione non ti aiuterà.

Secondo la risposta di ahmed_khan_89 , puoi inserire il tuo "codice di copia" all'interno dei sapori del prodotto.

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

Quindi non è necessario cambiare le impostazioni manualmente.

Sto usando il file google-services.json, creato da qui: https://developers.google.com/mobile/add?platform=android&cntapi=gcm&cnturl=https:%2F%2Fdevelopers.google.com%2Fcloud-messaging % 2Fandroid% 2Fclient & cntlbl = Continua% 20Adding% 20GCM% 20Support &% 3Fconfigured% 3Dtrue

Nella struttura JSON c'è un array JSON chiamato client. Se hai più gusti, aggiungi qui le diverse proprietà.

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

Nel mio progetto sto usando lo stesso ID progetto e quando aggiungo il secondo nome del pacchetto nell'URL sopra, google mi fornisce un file contenente più client nei dati json.

Ci scusiamo per i dati JSON compatti. Non sono riuscito a formattarlo correttamente ...

Il file google-services.json non è necessario per ricevere le notifiche. Aggiungi una variabile per ogni sapore nel tuo file build.gradle:

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

Utilizzare questa variabile BuildConfig.GCM_SENDER_ID invece di getString (R.string.gcm_defaultSenderId) durante la registrazione:

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

1.) Cosa fa veramente google-services.json?

Segui questo: https://stackoverflow.com/a/31598587/2382964

2.) In che modo il file google-services.json influenza il tuo progetto Android Studio?

Segui questo: https://stackoverflow.com/a/33083898/2382964

in breve per il secondo url, se aggiungi google-services.json nel tuo progetto ci deve essere una google-servicescartella generata automaticamente per la debugvariante in questo percorso

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

3.) Cosa fare, per farlo?

aggiungi la dipendenza google-services in project_levelbuild.gradle, puoi anche usare version 3.0.0se stai usando la libreria app_compact.

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

ora in app_levelbuild.gradle devi aggiungere in fondo.

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

4.) Dove inserire il file google-service.json nella tua struttura.

case 1.) se non hai build_flavor inseriscilo al suo interno /app/google-service.json cartella.

caso 2.) se hai più build_flavor e hai file google_services.json diversi e diversi messi dentro app/src/build_flavor/google-service.json .

caso 3.) se hai più build_flavor e hai un singolo file google_services.json inserito all'interno app/google-service.json.

Non è necessario alcun ulteriore script di gradle.

Google ha iniziato ad aggiungere un nome di pacchetto diverso nel nome di "android_client_info". Sembra di seguito in google-services.json

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

quindi, i seguenti passaggi sono sufficienti per avere una diversa selezione di google-services.json.

1. Hai 2 gusti
2. Aggiungi un nuovo pacchetto dev flavour alla pagina di configurazione di Google Analystics e scarica google-services.json.
3. Si noti nel nuovo file di configurazione, entrambi gli ID del pacchetto di flavour sono lì
4. Prepara una qualsiasi delle tue creazioni aromatiche.

Questo è tutto! ..

Abbiamo un nome di pacchetto diverso per le build di debug (* .debug), quindi volevo qualcosa che funzioni basato su flavour e buildType, senza dover scrivere nulla relativo al sapore nel modello di processDebugFlavorGoogleServices.

Ho creato una cartella denominata "google-services" in ogni versione, contenente sia la versione di debug che la versione di rilascio del file json:

Nella sezione buildTypes del tuo file gradle, aggiungi questo:

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

Copierà automaticamente il file json giusto nella radice del modulo dell'app quando cambierai la variante di build.

Aggiungi i due metodi chiamati per ottenere il sapore e il tipo di build correnti nella radice di 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 "";
}

Questo è tutto, non devi preoccuparti di rimuovere / aggiungere / modificare sapori dal tuo file gradle e ottiene automaticamente il debug o il rilascio google-services.json.

Firebase ora supporta più ID applicazione con un solo file google-services.json.

Questo post sul blog lo descrive in dettaglio.

Creerai un progetto principale in Firebase che utilizzerai per tutte le tue varianti. Quindi crei applicazioni Android separate in Firebase sotto quel progetto per ogni ID applicazione che hai.

Quando hai creato tutte le tue varianti, puoi scaricare un google-services.json che supporta tutti gli ID delle tue applicazioni. Quando è pertinente visualizzare i dati separatamente (ad es. Segnalazione di arresti anomali) puoi attivarli con un menu a discesa.

Secondo i documenti di Firebase puoi anche utilizzare le risorse di stringa anziché google-services.json .

Poiché questo provider sta semplicemente leggendo le risorse con nomi noti, un'altra opzione è quella di aggiungere le risorse di stringa direttamente alla tua app anziché utilizzare il plug-in gradle di Servizi Google. Puoi farlo tramite:

• Rimozione del google-servicesplug-in dal root.gradle build
• Eliminazione google-services.jsondal progetto
• Aggiunta diretta delle risorse di stringa
• Eliminazione del plug-in di applicazione: 'com.google.gms.google-services'dall'app build.gradle

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

Basato sulla risposta di @ ZakTaccardi, e supponendo che tu non voglia un singolo progetto per entrambi i gusti, aggiungi questo alla fine del tuo build.gradlefile:

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
}

Devi avere i file src/staging/google-services.jsone src/production/google-services.json. Sostituisci i nomi dei sapori con quelli che usi.

Ho scoperto che il plug -in Google Services è abbastanza inutile per i progetti che vogliono aggiungere GCM. Genera solo il seguente file che aggiunge semplicemente l'ID del progetto come risorsa stringa:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- Your API key would be on the following line -->
    <string name="gcm_defaultSenderId">111111111111</string>
</resources>

Sembra che tu ne abbia bisogno solo se hai copiato il codice di esempio alla lettera direttamente dalla guida di Cloud Messaging per Android . Ecco la riga di esempio:

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

Soluzione

Se vuoi essere in grado di cambiare i progetti API per diversi tipi di build o gusti di prodotti, puoi semplicemente definire le tue costanti e scegliere quella appropriata quando chiami l' 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);

Per i sapori del prodotto

Il codice sopra funziona per il passaggio tra build di debug e build di rilascio. Per gli aromi di prodotto, definire le diverse chiavi API in un file sorgente Java e posizionare i file nella corrispondente directory di aromi del prodotto. Per riferimento: Varianti Build Gradle

AGGIORNAMENTO:

In termini di configurazione di Firebase con varianti di build, fare riferimento a questo blog che contiene istruzioni dettagliate.

Lo scopo del plug-in Google Services è semplificare l'integrazione delle funzionalità di Google.

Dal momento che genera solo risorse Android dal file google-services.json, penso che la logica del gradiente troppo complicata neghi questo punto.

Quindi, se i documenti di Google non dicono quali risorse sono necessarie per specifiche funzionalità di Google, suggerirei di generare il file JSON per ogni tipo / sapore pertinente, vedere quali risorse vengono generate dal plugin e quindi mettere quelle risorse manualmente nelle rispettive directory src / buildtypeORflavor / res.

Elimina quindi i riferimenti al plug-in dei servizi Google e al file JSON e il gioco è fatto.

Per informazioni dettagliate sul funzionamento interno del plug-in gradle di servizi Google, consultare la mia altra risposta:

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

Semplificando ciò che ha detto @Scotti. Devi creare app Multiples con un nome pacchetto diverso per un particolare Progetto a seconda del sapore del prodotto.

Supponiamo che il tuo progetto sia ABC con diversi gusti di prodotto X, Y dove X ha un nome di pacchetto com.x e Y ha un nome di pacchetto com.y quindi nella console di firebase devi creare un progetto ABC in cui devi creare 2 app con i nomi dei pacchetti com.x e com.y. Quindi devi scaricare il file google-services.json in cui ci saranno 2 oggetti informazioni client che conterranno quei pacakge e sarai a posto.

Un frammento di json sarebbe qualcosa del genere

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

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

    }

In effetti, juste one google-services.json nella MyApp/app/directory è buono, non c'è bisogno di script adizionali con com.google.gms:google-services:3.0.0. Ma fai attenzione a eliminare il file google-services.jsondalla directory dell'app MyApp/app/src/flavor1/res/per evitare il tipo di erroreExecution failed for task ':app:processDebugGoogleServices'. > No matching client found for package

Quindi, se si desidera copiare a livello di google-services.jsoncodice il file da tutte le varianti nella cartella principale. Quando passi a una variante specifica, ecco una soluzione per te

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

C'è un avvertimento in questo approccio che è necessario disporre di google-service.jsonfile in ciascuna cartella delle varianti, ecco un esempio.

Hai molti gusti, quindi significa che avrai un ID pacchetto con molte differenze, giusto? Quindi, vai alla pagina in cui hai impostato / generato il tuo file json e config per ogni nome di pacchetto. Tutto ciò verrà aggiunto al file json.

Sono molto pigro per pubblicare foto ora, ma fondamentalmente:

• vai a https://developers.google.com/mobile/add
• selezionare la piattaforma
• seleziona la tua app
• IMPORTANTE : digita il nome del pacchetto flavour nel campo "nome pacchetto android"
• ... continua a ottenere il tuo file di configurazione. Scaricalo!

Quando configuri il file, puoi vedere che google ti mostra la chiave API del server + ID mittente. Ed è lo stesso per tutti i pacchetti (sapori)

Alla fine, hai solo bisogno di un solo file json per tutti i gusti.

Un'altra domanda qui che devi verificare quando ti registri per ottenere il token di registrazione, controlla se c'è differenza per ogni sapore. Non lo tocco, ma penso che dovrebbe fare la differenza. Troppo tardi adesso e ho così sonno :) Spero che sia d'aiuto!

Hey Friends cerca anche l'uso del nome solo in minuscolo, quindi non si ottiene questo errore

Attualmente sto usando due ID progetto GCM nello stesso pacchetto di app. Ho inserito google-service.json del mio primo progetto GCM ma passo dal primo al secondo cambiando solo SENDER_ID:

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

(A questo punto penso che google-services.json non sia obbligatorio)

Ispirato dalla risposta @ ahmed_khan_89 sopra. Possiamo tenere direttamente così in file 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
}

Inserisci il tuo file "google-services.json" rispettivamente in app / src / flavours quindi in build.gradle dell'app, sotto android aggiungi sotto il codice

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