title: Cannot add extension with name 'googleServices' on gradle sync
body: <p>I'm working with ionic and I build an application that uses cordova-plugin-firebase for messaging and the analytics plugin too.</p>
  
  <p>When I build this app for Android, I went to android studio to test, but gradle isn't syncing. First I got an error "Plugin with id 'com.google.gms.google-services' not found.". </p>
  
  <p>To solve this I put the dependency "classpath 'com.google.gms:google-services:4.0.2'" inside buildscript on the /app/gradle.build.</p>
  
  <p>Now I get this error:</p>
  
  <p>Cannot add extension with name 'googleServices', as there is an extension already registered with that name.</p>
  
  <p>Does someone have the same error?</p>
  
  <p>Thank you all for your help.</p>
  
  <p>This is gradle.build</p>
  
  <pre><code>apply plugin: 'com.android.application'
  
  buildscript {
      repositories {
          mavenCentral()
          jcenter()
          maven {
              url "https://maven.google.com"
          }
      }
  
      dependencies {
          classpath 'com.android.tools.build:gradle:3.0.1'
      }
  }
  
  // Allow plugins to declare Maven dependencies via build-extras.gradle.
  allprojects {
      repositories {
          mavenCentral();
          jcenter()
      }
  }
  
  task wrapper(type: Wrapper) {
      gradleVersion = '4.1.0'
  }
  
  // Configuration properties. Set these via environment variables, build-extras.gradle, or gradle.properties.
  // Refer to: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
  ext {
      apply from: '../CordovaLib/cordova.gradle'
      // The value for android.compileSdkVersion.
      if (!project.hasProperty('cdvCompileSdkVersion')) {
          cdvCompileSdkVersion = null;
      }
      // The value for android.buildToolsVersion.
      if (!project.hasProperty('cdvBuildToolsVersion')) {
          cdvBuildToolsVersion = null;
      }
      // Sets the versionCode to the given value.
      if (!project.hasProperty('cdvVersionCode')) {
          cdvVersionCode = null
      }
      // Sets the minSdkVersion to the given value.
      if (!project.hasProperty('cdvMinSdkVersion')) {
          cdvMinSdkVersion = null
      }
      // Whether to build architecture-specific APKs.
      if (!project.hasProperty('cdvBuildMultipleApks')) {
          cdvBuildMultipleApks = null
      }
      // Whether to append a 0 "abi digit" to versionCode when only a single APK is build 
      if (!project.hasProperty('cdvVersionCodeForceAbiDigit')) {
          cdvVersionCodeForceAbiDigit = null
      }
      // .properties files to use for release signing.
      if (!project.hasProperty('cdvReleaseSigningPropertiesFile')) {
          cdvReleaseSigningPropertiesFile = null
      }
      // .properties files to use for debug signing.
      if (!project.hasProperty('cdvDebugSigningPropertiesFile')) {
          cdvDebugSigningPropertiesFile = null
      }
      // Set by build.js script.
      if (!project.hasProperty('cdvBuildArch')) {
          cdvBuildArch = null
      }
  
      // Plugin gradle extensions can append to this to have code run at the end.
      cdvPluginPostBuildExtras = []
  }
  
  // PLUGIN GRADLE EXTENSIONS START
  apply from: "../cordova-plugin-appsflyer-sdk/academybeautyclub-cordovaAF.gradle"
  apply from: "../cordova-plugin-firebase/academybeautyclub-build.gradle"
  apply from: "../cordova-support-google-services/academybeautyclub-build.gradle"
  // PLUGIN GRADLE EXTENSIONS END
  
  def hasBuildExtras = file('build-extras.gradle').exists()
  if (hasBuildExtras) {
      apply from: 'build-extras.gradle'
  }
  
  // Set property defaults after extension .gradle files.
  if (ext.cdvCompileSdkVersion == null) {
      ext.cdvCompileSdkVersion = privateHelpers.getProjectTarget()
      //ext.cdvCompileSdkVersion = project.ext.defaultCompileSdkVersion
  }
  if (ext.cdvBuildToolsVersion == null) {
      ext.cdvBuildToolsVersion = privateHelpers.findLatestInstalledBuildTools()
      //ext.cdvBuildToolsVersion = project.ext.defaultBuildToolsVersion
  }
  if (ext.cdvDebugSigningPropertiesFile == null &amp;&amp; file('../debug-signing.properties').exists()) {
      ext.cdvDebugSigningPropertiesFile = '../debug-signing.properties'
  }
  if (ext.cdvReleaseSigningPropertiesFile == null &amp;&amp; file('../release-signing.properties').exists()) {
      ext.cdvReleaseSigningPropertiesFile = '../release-signing.properties'
  }
  
  // Cast to appropriate types.
  ext.cdvBuildMultipleApks = cdvBuildMultipleApks == null ? false : cdvBuildMultipleApks.toBoolean();
  ext.cdvVersionCodeForceAbiDigit = cdvVersionCodeForceAbiDigit == null ? false : cdvVersionCodeForceAbiDigit.toBoolean();
  ext.cdvMinSdkVersion = cdvMinSdkVersion == null ? null : defaultMinSdkVersion
  ext.cdvVersionCode = cdvVersionCode == null ? null : Integer.parseInt('' + cdvVersionCode)
  
  def computeBuildTargetName(debugBuild) {
      def ret = 'assemble'
      if (cdvBuildMultipleApks &amp;&amp; cdvBuildArch) {
          def arch = cdvBuildArch == 'arm' ? 'armv7' : cdvBuildArch
          ret += '' + arch.toUpperCase().charAt(0) + arch.substring(1);
      }
      return ret + (debugBuild ? 'Debug' : 'Release')
  }
  
  // Make cdvBuild a task that depends on the debug/arch-sepecific task.
  task cdvBuildDebug
  cdvBuildDebug.dependsOn {
      return computeBuildTargetName(true)
  }
  
  task cdvBuildRelease
  cdvBuildRelease.dependsOn {
      return computeBuildTargetName(false)
  }
  
  task cdvPrintProps &lt;&lt; {
      println('cdvCompileSdkVersion=' + cdvCompileSdkVersion)
      println('cdvBuildToolsVersion=' + cdvBuildToolsVersion)
      println('cdvVersionCode=' + cdvVersionCode)
      println('cdvVersionCodeForceAbiDigit=' + cdvVersionCodeForceAbiDigit)
      println('cdvMinSdkVersion=' + cdvMinSdkVersion)
      println('cdvBuildMultipleApks=' + cdvBuildMultipleApks)
      println('cdvReleaseSigningPropertiesFile=' + cdvReleaseSigningPropertiesFile)
      println('cdvDebugSigningPropertiesFile=' + cdvDebugSigningPropertiesFile)
      println('cdvBuildArch=' + cdvBuildArch)
      println('computedVersionCode=' + android.defaultConfig.versionCode)
      android.productFlavors.each { flavor -&gt;
          println('computed' + flavor.name.capitalize() + 'VersionCode=' + flavor.versionCode)
      }
  }
  
  android {
  
      defaultConfig {
          versionCode cdvVersionCode ?: new BigInteger("" + privateHelpers.extractIntFromManifest("versionCode"))
          applicationId privateHelpers.extractStringFromManifest("package")
  
          if (cdvMinSdkVersion != null) {
              minSdkVersion cdvMinSdkVersion
          }
      }
  
      lintOptions {
        abortOnError false;
      }
  
      compileSdkVersion cdvCompileSdkVersion
      buildToolsVersion cdvBuildToolsVersion
  
      //This code exists for Crosswalk and other Native APIs.
      //By default, we multiply the existing version code in the Android Manifest by 10 and 
      //add a number for each architecture.  If you are not using Crosswalk or SQLite, you can
      //ignore this chunk of code, and your version codes will be respected.
  
      if (Boolean.valueOf(cdvBuildMultipleApks)) {
          flavorDimensions "default"
  
          productFlavors {
              armeabi {
                  versionCode defaultConfig.versionCode*10 + 1
                  ndk {
                      abiFilters = ["armeabi"]
                  }
              }
              armv7 {
                  versionCode defaultConfig.versionCode*10 + 2
                  ndk {
                      abiFilters = ["armeabi-v7a"]
                  }
              }
              arm64 {
                  versionCode defaultConfig.versionCode*10 + 3
                  ndk {
                      abiFilters = ["arm64-v8a"]
                  }
              }
              x86 {
                  versionCode defaultConfig.versionCode*10 + 4
                  ndk {
                      abiFilters = ["x86"]
                  }
              }
              x86_64 {
                  versionCode defaultConfig.versionCode*10 + 5
                  ndk {
                      abiFilters = ["x86_64"]
                  }
              }
          }
      } else if (Boolean.valueOf(cdvVersionCodeForceAbiDigit)) {
          // This provides compatibility to the default logic for versionCode before cordova-android 5.2.0
          defaultConfig {
              versionCode defaultConfig.versionCode*10
          }
      }
  
      compileOptions {
          sourceCompatibility JavaVersion.VERSION_1_8
          targetCompatibility JavaVersion.VERSION_1_8
      }
  
      if (cdvReleaseSigningPropertiesFile) {
          signingConfigs {
              release {
                  // These must be set or Gradle will complain (even if they are overridden).
                  keyAlias = ""
                  keyPassword = "__unset" // And these must be set to non-empty in order to have the signing step added to the task graph.
                  storeFile = null
                  storePassword = "__unset"
              }
          }
          buildTypes {
              release {
                  signingConfig signingConfigs.release
              }
          }
          addSigningProps(cdvReleaseSigningPropertiesFile, signingConfigs.release)
      }
      if (cdvDebugSigningPropertiesFile) {
          addSigningProps(cdvDebugSigningPropertiesFile, signingConfigs.debug)
      }
  }
  
  /*
   * WARNING: Cordova Lib and platform scripts do management inside of this code here,
   * if you are adding the dependencies manually, do so outside the comments, otherwise
   * the Cordova tools will overwrite them
   */
  
  
  dependencies {
      implementation fileTree(dir: 'libs', include: '*.jar')
      // SUB-PROJECT DEPENDENCIES START
      implementation(project(path: ":CordovaLib"))
      compile "com.google.android.gms:play-services-tagmanager:+"
      //compile "com.google.firebase:firebase-core:+"
      compile "com.google.firebase:firebase-messaging:+"
      compile "com.google.firebase:firebase-config:+"
      compile "com.google.firebase:firebase-perf:+"
      compile "com.google.firebase:firebase-core:16.0.3"
      // SUB-PROJECT DEPENDENCIES END
  }
  
  def promptForReleaseKeyPassword() {
      if (!cdvReleaseSigningPropertiesFile) {
          return;
      }
      if ('__unset'.equals(android.signingConfigs.release.storePassword)) {
          android.signingConfigs.release.storePassword = privateHelpers.promptForPassword('Enter key store password: ')
      }
      if ('__unset'.equals(android.signingConfigs.release.keyPassword)) {
          android.signingConfigs.release.keyPassword = privateHelpers.promptForPassword('Enter key password: ');
      }
  }
  
  gradle.taskGraph.whenReady { taskGraph -&gt;
      taskGraph.getAllTasks().each() { task -&gt;
        if(['validateReleaseSigning', 'validateSigningRelease', 'validateSigningArmv7Release', 'validateSigningX76Release'].contains(task.name)) {
           promptForReleaseKeyPassword()
        }
      }
  }
  
  def addSigningProps(propsFilePath, signingConfig) {
      def propsFile = file(propsFilePath)
      def props = new Properties()
      propsFile.withReader { reader -&gt;
          props.load(reader)
      }
  
      def storeFile = new File(props.get('key.store') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'storeFile'))
      if (!storeFile.isAbsolute()) {
          storeFile = RelativePath.parse(true, storeFile.toString()).getFile(propsFile.getParentFile())
      }
      if (!storeFile.exists()) {
          throw new FileNotFoundException('Keystore file does not exist: ' + storeFile.getAbsolutePath())
      }
      signingConfig.keyAlias = props.get('key.alias') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'keyAlias')
      signingConfig.keyPassword = props.get('keyPassword', props.get('key.alias.password', signingConfig.keyPassword))
      signingConfig.storeFile = storeFile
      signingConfig.storePassword = props.get('storePassword', props.get('key.store.password', signingConfig.storePassword))
      def storeType = props.get('storeType', props.get('key.store.type', ''))
      if (!storeType) {
          def filename = storeFile.getName().toLowerCase();
          if (filename.endsWith('.p12') || filename.endsWith('.pfx')) {
              storeType = 'pkcs12'
          } else {
              storeType = signingConfig.storeType // "jks"
          }
      }
      signingConfig.storeType = storeType
  }
  
  for (def func : cdvPluginPostBuildExtras) {
      func()
  }
  
  // This can be defined within build-extras.gradle as:
  //     ext.postBuildExtras = { ... code here ... }
  if (hasProperty('postBuildExtras')) {
      postBuildExtras()
  }
  
  apply plugin: 'com.google.gms.google-services'
  </code></pre>