title: Ionic cordova compile failed for Android package does not exist
body: <p>I'm working on an app using Ionic 5 and Cordova 10, it seems plugins that use androidx packages activate the android.useAndroidX=true and the compile is failing:</p>
  <ol>
  <li>Ionic 5.4.16</li>
  <li>Cordova 10.0.0</li>
  <li>Gradle 6.5.1</li>
  <li>Angular CLI 9.1.9</li>
  <li>Android Studio 4.4.1</li>
  <li>Both Android 29 and 30 sdk installed on my in local machine and configured in my machine variables.</li>
  </ol>
  <p>I am using these cordova plugins:</p>
  <pre><code>&lt;plugin name=&quot;cordova-plugin-whitelist&quot; spec=&quot;1.3.3&quot; /&gt;
  &lt;plugin name=&quot;cordova-plugin-statusbar&quot; spec=&quot;2.4.2&quot; /&gt;
  &lt;plugin name=&quot;cordova-plugin-device&quot; spec=&quot;2.0.2&quot; /&gt;
  &lt;plugin name=&quot;cordova-plugin-splashscreen&quot; spec=&quot;5.0.2&quot; /&gt;
  &lt;plugin name=&quot;cordova-plugin-ionic-webview&quot; spec=&quot;4.0.0&quot; /&gt;
  &lt;plugin name=&quot;cordova-plugin-ionic-keyboard&quot; spec=&quot;2.0.5&quot; /&gt;
  </code></pre>
  <p>Since when i added cordova-plugin-fingerprint-aio, when I try to compile project for android it fails, here my script:</p>
  <pre><code>ionic cordova platform remove android
  ionic cordova platform add android
  ionic cordova platform build android
  ionic cordova platform compile android
  </code></pre>
  <p>While i'm building it I see these warnings:</p>
  <pre><code>config file undefined requested for changes not found at C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\undefined, ignoring
  config file undefined requested for changes not found at C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\undefined, ignoring
  [Gradle Properties] Detected Gradle property &quot;android.useAndroidX&quot; with the value of &quot;true&quot;, Cordova's recommended value is &quot;false&quot;
  [Gradle Properties] Detected Gradle property &quot;android.enableJetifier&quot; with the value of &quot;true&quot;, Cordova's recommended value is &quot;false&quot;
  The &quot;path&quot; argument must be of type string. Received undefined
  </code></pre>
  <p>And when i compile it:</p>
  <pre><code>Task :app:compileDebugJavaWithJavac
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\com\ionicframework\cordova\webview\IonicWebViewEngine.java:11: error: package android.support.annotation does not exist
  import android.support.annotation.RequiresApi;
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\org\apache\cordova\camera\CameraLauncher.java:42: error: package android.support.v4.content does not exist
  import android.support.v4.content.FileProvider;
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\org\apache\cordova\camera\FileProvider.java:21: error: package android.support.v4.content does not exist
  public class FileProvider extends android.support.v4.content.FileProvider {}
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\com\ionicframework\cordova\webview\IonicWebViewEngine.java:137: error: cannot find symbol
      @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
       ^
    symbol:   class RequiresApi
    location: class IonicWebViewEngine.ServerClient
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\org\apache\cordova\camera\CameraLauncher.java:296: error: cannot find symbol
          this.imageUri = FileProvider.getUriForFile(cordova.getActivity(),
                                      ^
    symbol:   method getUriForFile(Activity,String,File)
    location: class FileProvider
  C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\app\src\main\java\org\apache\cordova\camera\CameraLauncher.java:823: error: cannot find symbol
                          Uri tmpFile = FileProvider.getUriForFile(cordova.getActivity(),
                                                    ^
    symbol:   method getUriForFile(Activity,String,File)
    location: class FileProvider
  Note: Some input files use or override a deprecated API.
  Note: Recompile with -Xlint:deprecation for details.
  Note: Some input files use unchecked or unsafe operations.
  Note: Recompile with -Xlint:unchecked for details.
  6 errors
  
  &gt; Task :app:compileDebugJavaWithJavac FAILED
  
  FAILURE: Build failed with an exception.
  
  * What went wrong:
  Execution failed for task ':app:compileDebugJavaWithJavac'.
  &gt; Compilation failed; see the compiler error output for details.
  
  * Try:
  Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
  
  * Get more help at https://help.gradle.org
  
  Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
  Use '--warning-mode all' to show the individual deprecation warnings.
  See https://docs.gradle.org/6.5/userguide/command_line_interface.html#sec:command_line_warnings
  
  BUILD FAILED in 43s
  21 actionable tasks: 1 executed, 20 up-to-date
  Command failed with exit code 1: C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\platforms\android\gradlew cdvBuildDebug -b C:\Users\&lt;myuser&gt;\IonicProjects\&lt;myapp&gt;\\platforms\android\build.gradle
  [ERROR] An error occurred while running subprocess cordova.
  
          cordova.cmd compile android exited with exit code 1.
  
          Re-running this command with the --verbose flag may provide more information.
  
  </code></pre>
  <p>I also tried to add cordova-plugin-androidx-adapter but nothing has changed.</p>
  <p>If I remove cordova-plugin-fingerprint-aio it works.</p>
  <p>I tried to migrate to AndroidX but Android Studio alerts &quot;No Usages Found in the project&quot;.</p>
  <p>Here is my build.gradle</p>
  <pre><code>/*
         Licensed to the Apache Software Foundation (ASF) under one
         or more contributor license agreements.  See the NOTICE file
         distributed with this work for additional information
         regarding copyright ownership.  The ASF licenses this file
         to you under the Apache License, Version 2.0 (the
         &quot;License&quot;); you may not use this file except in compliance
         with the License.  You may obtain a copy of the License at
  
           http://www.apache.org/licenses/LICENSE-2.0
  
         Unless required by applicable law or agreed to in writing,
         software distributed under the License is distributed on an
         &quot;AS IS&quot; BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
         KIND, either express or implied.  See the License for the
         specific language governing permissions and limitations
         under the License.
  */
  
  apply plugin: 'com.android.application'
  
  if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
      apply plugin: 'kotlin-android'
      apply plugin: 'kotlin-android-extensions'
  }
  
  buildscript {
      apply from: '../CordovaLib/cordova.gradle'
  
      if(cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
          String defaultGradlePluginKotlinVersion = kotlin_version
  
          /**
           * Fetches the user's defined Kotlin Version from config.xml.
           * If the version is not set or invalid, it will default to the ${defaultGradlePluginKotlinVersion}
           */
          String gradlePluginKotlinVersion = cdvHelpers.getConfigPreference('GradlePluginKotlinVersion', defaultGradlePluginKotlinVersion)
          if(!cdvHelpers.isVersionValid(gradlePluginKotlinVersion)) {
              println(&quot;The defined Kotlin version (${gradlePluginKotlinVersion}) does not appear to be a valid version. Falling back to version: ${defaultGradlePluginKotlinVersion}.&quot;)
              gradlePluginKotlinVersion = defaultGradlePluginKotlinVersion
          }
  
          // Change the version to be used.
          ext.kotlin_version = gradlePluginKotlinVersion
      }
  
      repositories {
          mavenCentral()
          google()
          jcenter()
      }
  
      dependencies {
          apply from: '../CordovaLib/cordova.gradle'
  
          classpath 'com.android.tools.build:gradle:4.0.0'
  
          if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
              classpath &quot;org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version&quot;
          }
  
          if(cdvHelpers.getConfigPreference('GradlePluginGoogleServicesEnabled', 'false').toBoolean()) {
              String defaultGradlePluginGoogleServicesVersion = '4.2.0'
  
              /**
               * Fetches the user's defined Google Services Plugin Version from config.xml.
               * If the version is not set or invalid, it will default to the ${defaultGradlePluginGoogleServicesVersion}
               */
              String gradlePluginGoogleServicesVersion = cdvHelpers.getConfigPreference('GradlePluginGoogleServicesVersion', defaultGradlePluginGoogleServicesVersion)
              if(!cdvHelpers.isVersionValid(gradlePluginGoogleServicesVersion)) {
                  println(&quot;The defined Google Services plugin version (${gradlePluginGoogleServicesVersion}) does not appear to be a valid version. Falling back to version: ${defaultGradlePluginGoogleServicesVersion}.&quot;)
                  gradlePluginGoogleServicesVersion = defaultGradlePluginGoogleServicesVersion
              }
  
              // Create the Google Services classpath and set it.
              String gradlePluginGoogleServicesClassPath = &quot;com.google.gms:google-services:${gradlePluginGoogleServicesVersion}&quot;
              println &quot;Adding classpath: ${gradlePluginGoogleServicesClassPath}&quot;
              classpath gradlePluginGoogleServicesClassPath
          }
      }
  }
  
  // Allow plugins to declare Maven dependencies via build-extras.gradle.
  allprojects {
      repositories {
          mavenCentral()
          jcenter()
      }
  }
  
  task wrapper(type: Wrapper) {
      gradleVersion = '6.5'
  }
  
  // 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
      }
      // Sets the maxSdkVersion to the given value.
      if (!project.hasProperty('cdvMaxSdkVersion')) {
          cdvMaxSdkVersion = null
      }
      // The value for android.targetSdkVersion.
      if (!project.hasProperty('cdvTargetSdkVersion')) {
          cdvTargetSdkVersion = null;
      }
      // Whether to build architecture-specific APKs.
      if (!project.hasProperty('cdvBuildMultipleApks')) {
          cdvBuildMultipleApks = null
      }
      // Whether to append a 0 &quot;abi digit&quot; 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: &quot;../cordova-plugin-fingerprint-aio/starter-build.gradle&quot;
  // PLUGIN GRADLE EXTENSIONS END
  
  def hasBuildExtras1 = file('build-extras.gradle').exists()
  if (hasBuildExtras1) {
      apply from: 'build-extras.gradle'
  }
  
  def hasBuildExtras2 = file('../build-extras.gradle').exists()
  if (hasBuildExtras2) {
      apply from: '../build-extras.gradle'
  }
  
  // Set property defaults after extension .gradle files.
  ext.cdvCompileSdkVersion = cdvCompileSdkVersion == null ? (
      defaultCompileSdkVersion == null
          ? privateHelpers.getProjectTarget()
          : defaultCompileSdkVersion
  ) : Integer.parseInt('' + cdvCompileSdkVersion);
  
  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();
  
  // minSdkVersion, maxSdkVersion and targetSdkVersion
  ext.cdvMinSdkVersion = cdvMinSdkVersion == null ? defaultMinSdkVersion : Integer.parseInt('' + cdvMinSdkVersion)
  if (cdvMaxSdkVersion != null) {
      ext.cdvMaxSdkVersion = Integer.parseInt('' + cdvMaxSdkVersion)
  }
  ext.cdvTargetSdkVersion = cdvTargetSdkVersion == null ? defaultTargetSdkVersion  : Integer.parseInt('' + cdvTargetSdkVersion)
  
  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 {
      doLast {
          println('cdvCompileSdkVersion=' + cdvCompileSdkVersion)
          println('cdvBuildToolsVersion=' + cdvBuildToolsVersion)
          println('cdvVersionCode=' + cdvVersionCode)
          println('cdvVersionCodeForceAbiDigit=' + cdvVersionCodeForceAbiDigit)
          println('cdvMinSdkVersion=' + cdvMinSdkVersion)
          println('cdvMaxSdkVersion=' + cdvMaxSdkVersion)
          println('cdvTargetSdkVersion=' + cdvTargetSdkVersion)
          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(&quot;&quot; + privateHelpers.extractIntFromManifest(&quot;versionCode&quot;))
          applicationId privateHelpers.extractStringFromManifest(&quot;package&quot;)
  
          if (cdvMinSdkVersion != null) {
              minSdkVersion cdvMinSdkVersion
          }
  
          if (cdvMaxSdkVersion != null) {
              maxSdkVersion cdvMaxSdkVersion
          }
  
          if(cdvTargetSdkVersion != null) {
              targetSdkVersion cdvTargetSdkVersion
          }
      }
  
      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 &quot;default&quot;
  
          productFlavors {
              armeabi {
                  versionCode defaultConfig.versionCode*10 + 1
                  ndk {
                      abiFilters = [&quot;armeabi&quot;]
                  }
              }
              armv7 {
                  versionCode defaultConfig.versionCode*10 + 2
                  ndk {
                      abiFilters = [&quot;armeabi-v7a&quot;]
                  }
              }
              arm64 {
                  versionCode defaultConfig.versionCode*10 + 3
                  ndk {
                      abiFilters = [&quot;arm64-v8a&quot;]
                  }
              }
              x86 {
                  versionCode defaultConfig.versionCode*10 + 4
                  ndk {
                      abiFilters = [&quot;x86&quot;]
                  }
              }
              x86_64 {
                  versionCode defaultConfig.versionCode*10 + 5
                  ndk {
                      abiFilters = [&quot;x86_64&quot;]
                  }
              }
          }
      } 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 = &quot;&quot;
                  keyPassword = &quot;__unset&quot; // And these must be set to non-empty in order to have the signing step added to the task graph.
                  storeFile = null
                  storePassword = &quot;__unset&quot;
              }
          }
          buildTypes {
              release {
                  signingConfig signingConfigs.release
              }
          }
          addSigningProps(cdvReleaseSigningPropertiesFile, signingConfigs.release)
      }
  
      if (cdvDebugSigningPropertiesFile) {
          addSigningProps(cdvDebugSigningPropertiesFile, signingConfigs.debug)
      }
  
      sourceSets {
          main.java.srcDirs += 'src/main/kotlin'
      }
  }
  
  /*
   * 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')
  
      if (cdvHelpers.getConfigPreference('GradlePluginKotlinEnabled', 'false').toBoolean()) {
          implementation &quot;org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version&quot;
      }
  
      // SUB-PROJECT DEPENDENCIES START
      implementation(project(path: &quot;:CordovaLib&quot;))
      implementation &quot;com.android.support:support-v4:27.+&quot;
      implementation &quot;com.google.android.gms:play-services-fitness:16.0.1&quot;
      implementation &quot;com.android.support:support-annotations:27.+&quot;
      // 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 // &quot;jks&quot;
          }
      }
      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()
  }
  
  if (cdvHelpers.getConfigPreference('GradlePluginGoogleServicesEnabled', 'false').toBoolean()) {
      apply plugin: 'com.google.gms.google-services'
  }
  
  </code></pre>
  <p>Any suggest?</p>