@nativescript/android 8.7.0 → 8.8.0-alpha.1

package/framework/app/build.gradle

@@ -20,9 +20,8 @@
 *            -PappResourcesPath=[app_resources_path]
 */
 
-
-import groovy.io.FileType
 import groovy.json.JsonSlurper
+import groovy.xml.XmlSlurper
 import org.apache.commons.io.FileUtils
 
 import javax.inject.Inject
@@ -30,26 +29,17 @@ import java.nio.file.Files
 import java.nio.file.Paths
 import java.nio.file.StandardCopyOption
 import java.security.MessageDigest
-
 import java.util.jar.JarEntry
 import java.util.jar.JarFile
 
 import static org.gradle.internal.logging.text.StyledTextOutput.Style
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
 
 apply plugin: "com.android.application"
 apply from: "gradle-helpers/BuildToolTask.gradle"
 apply from: "gradle-helpers/CustomExecutionLogger.gradle"
 apply from: "gradle-helpers/AnalyticsCollector.gradle"
-
-def enableKotlin = (project.hasProperty("useKotlin") && project.useKotlin == "true")
-
-if (enableKotlin) {
-    apply plugin: 'kotlin-android'
-    apply plugin: 'kotlin-parcelize'
-}
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-parcelize'
 
 def onlyX86 = project.hasProperty("onlyX86")
 if (onlyX86) {
@@ -86,7 +76,6 @@ def METADATA_JAVA_OUT = "mdg-java-out.txt"
 def pluginsJarLibraries = new LinkedList<String>()
 def allJarLibraries = new LinkedList<String>()
 
-def computeKotlinVersion = { -> project.hasProperty("kotlinVersion") ? kotlinVersion : "${ns_default_kotlin_version}" }
 def computeCompileSdkVersion = { -> project.hasProperty("compileSdk") ? compileSdk : NS_DEFAULT_COMPILE_SDK_VERSION as int }
 def computeTargetSdkVersion = { -> project.hasProperty("targetSdk") ? targetSdk : NS_DEFAULT_COMPILE_SDK_VERSION as int }
 def computeBuildToolsVersion = { ->
@@ -98,7 +87,7 @@ def enableVerboseMDG = project.gradle.startParameter.logLevel.name() == 'DEBUG'
 def analyticsFilePath = "$rootDir/analytics/build-statistics.json"
 def analyticsCollector = project.ext.AnalyticsCollector.withOutputPath(analyticsFilePath)
 if (enableAnalytics) {
-    analyticsCollector.markUseKotlinPropertyInApp(enableKotlin)
+    analyticsCollector.markUseKotlinPropertyInApp(true)
     analyticsCollector.writeAnalyticsFile()
 }
 
@@ -185,6 +174,7 @@ def setAppIdentifier = { ->
         if (appIdentifier) {
             project.ext.nsApplicationIdentifier = appIdentifier
             android.defaultConfig.applicationId = appIdentifier
+            android.namespace = appIdentifier
         }
     }
 }
@@ -193,14 +183,12 @@ android {
 
     applyBeforePluginGradleConfiguration()
 
-    if (enableKotlin) {
-        kotlinOptions {
-            jvmTarget = '1.8'
-        }
+    kotlinOptions {
+        jvmTarget = '17'
     }
 
-    compileSdkVersion computeCompileSdkVersion()
-    buildToolsVersion computeBuildToolsVersion()
+    compileSdk computeCompileSdkVersion()
+    buildToolsVersion = computeBuildToolsVersion()
 
     defaultConfig {
         def manifest = new XmlSlurper().parse(file(android.sourceSets.main.manifest.srcFile))
@@ -217,8 +205,8 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
 
     sourceSets.main {
@@ -247,17 +235,18 @@ android {
         }
     }
 
+    namespace "com.tns.testapplication"
     setAppIdentifier()
     applyPluginGradleConfigurations()
     applyAppGradleConfiguration()
 
     def initializeMergedAssetsOutputPath = { ->
-      android.applicationVariants.all { variant ->
+      android.applicationVariants.configureEach { variant ->
           if (variant.buildType.name == project.selectedBuildType) {
               def task
               if (variant.metaClass.respondsTo(variant, "getMergeAssetsProvider")) {
                   def provider = variant.getMergeAssetsProvider()
-                  task = provider.get();
+                  task = provider.get()
               } else {
                   // fallback for older android gradle plugin versions
                   task = variant.getMergeAssets()
@@ -265,7 +254,7 @@ android {
               for (File file : task.getOutputs().getFiles()) {
                   if (!file.getPath().contains("${File.separator}incremental${File.separator}")) {
                       project.ext.mergedAssetsOutputPath = file.getPath()
-                      break;
+                      break
                   }
               }
           }
@@ -395,18 +384,13 @@ dependencies {
         implementation project(':runtime')
     }
 
-    def kotlinVersion = computeKotlinVersion()
-    if (enableKotlin) {
-        implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
-    }
-
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////// CONFIGURATION PHASE //////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////
 
-task addDependenciesFromNativeScriptPlugins {
+task 'addDependenciesFromNativeScriptPlugins' {
     nativescriptDependencies.each { dep ->
         def aarFiles = fileTree(dir: file("$rootDir/${dep.directory}/$PLATFORMS_ANDROID"), include: ["**/*.aar"])
         aarFiles.each { aarFile ->
@@ -427,7 +411,7 @@ task addDependenciesFromNativeScriptPlugins {
     }
 }
 
-task addDependenciesFromAppResourcesLibraries {
+task 'addDependenciesFromAppResourcesLibraries' {
     def appResourcesPath = getAppResourcesPath()
     def appResourcesLibraries = file("$appResourcesPath/Android/libs")
     if (appResourcesLibraries.exists()) {
@@ -451,47 +435,20 @@ task addDependenciesFromAppResourcesLibraries {
 }
 
 if (failOnCompilationWarningsEnabled()) {
-    tasks.withType(JavaCompile) {
+    tasks.withType(JavaCompile).configureEach {
         options.compilerArgs << '-Xlint:all' << "-Werror"
         options.deprecation = true
     }
 }
 
-tasks.whenTaskAdded({ DefaultTask currentTask ->
-    if (currentTask =~ /generate.+BuildConfig/) {
-        currentTask.finalizedBy(extractAllJars)
-        extractAllJars.finalizedBy(collectAllJars)
-    }
-    if (currentTask =~ /compile.+JavaWithJavac/) {
-        currentTask.dependsOn(runSbg)
-        currentTask.finalizedBy(buildMetadata)
-    }
-
-
-    if (currentTask =~ /compile.+Kotlin.+/) {
-        currentTask.dependsOn(runSbg)
-        currentTask.finalizedBy(buildMetadata)
-    }
-
-    if (currentTask =~ /merge.*Assets/) {
-        currentTask.dependsOn(buildMetadata)
-    }
-    // ensure buildMetadata is done before R8 to allow custom proguard from metadata
-    if (currentTask =~ /minify.*WithR8/) {
-        currentTask.dependsOn(buildMetadata)
-    }
-    if (currentTask =~ /assemble.*Debug/ || currentTask =~ /assemble.*Release/) {
-        currentTask.finalizedBy("validateAppIdMatch")
-    }
-})
 
 ////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////// EXECUTUION PHASE /////////////////////////////////////
+///////////////////////////// EXECUTION PHASE /////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////
 
 task runSbg(type: BuildToolTask) {
     dependsOn "collectAllJars"
-    def rootPath = "";
+    def rootPath = ""
     if (!findProject(':static-binding-generator').is(null)) {
         rootPath = Paths.get(project(':static-binding-generator').projectDir.path, "build/libs").toString()
         dependsOn ':static-binding-generator:jar'
@@ -505,7 +462,7 @@ task runSbg(type: BuildToolTask) {
     mainClass = "-jar"
 
     def paramz = new ArrayList<String>()
-    paramz.add(Paths.get(rootPath,"static-binding-generator.jar"))
+    paramz.add(Paths.get(rootPath, "static-binding-generator.jar"))
 
     if (failOnCompilationWarningsEnabled()) {
         paramz.add("-show-deprecation-warnings")
@@ -551,7 +508,7 @@ def explodeAar(File compileDependency, File outputDir) {
     }
 }
 
-def md5(String string) {
+static def md5(String string) {
     MessageDigest digest = MessageDigest.getInstance("MD5")
     digest.update(string.bytes)
     return new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
@@ -584,9 +541,9 @@ allprojects {
         def buildType = project.selectedBuildType
         def jars = []
         def artifactType = Attribute.of('artifactType', String)
-        android.applicationVariants.all { variant ->
+        android.applicationVariants.configureEach { variant ->
             if (variant.buildType.name == buildType) {
-                variant.getCompileClasspath().each { fileDependency -> 
+                variant.getCompileClasspath(null).each { fileDependency ->
                     processJar(fileDependency, jars)
                 }
             }
@@ -604,7 +561,7 @@ def processJar(File jar, jars) {
         logger.debug("Creating dynamic task ${taskName}")
 
         // Add discovered jars as dependencies of cleanupAllJars.
-        // This is cruicial for cloud builds because they are different
+        // This is crucial for cloud builds because they are different
         // on each incremental build (as each time the gradle user home
         // directory is a randomly generated string)
         cleanupAllJars.inputs.files jar
@@ -634,7 +591,7 @@ def processJar(File jar, jars) {
     }
 }
 
-task cleanupAllJars {
+task 'cleanupAllJars' {
     // We depend on the list of libs directories that might contain aar or jar files
     // and on the list of all discovered jars
     inputs.files(pluginDependencies)
@@ -659,7 +616,7 @@ task cleanupAllJars {
 
 
 // Placeholder task which depends on all dynamically generated extraction tasks
-task extractAllJars {
+task 'extractAllJars' {
     dependsOn cleanupAllJars
     outputs.files extractAllJarsTimestamp
 
@@ -668,7 +625,7 @@ task extractAllJars {
     }
 }
 
-task collectAllJars {
+task 'collectAllJars' {
     dependsOn extractAllJars
     description "gathers all paths to jar dependencies before building metadata with them"
 
@@ -711,22 +668,22 @@ task copyMetadataFilters(type: Copy) {
     into "$BUILD_TOOLS_PATH"
 }
 
-task copyMetadata {
+task 'copyMetadata' {
     doLast {
         copy {
-          from "$projectDir/src/main/assets/metadata"
-          into getMergedAssetsOutputPath() + "/metadata"
+            from "$projectDir/src/main/assets/metadata"
+            into getMergedAssetsOutputPath() + "/metadata"
         }
     }
 }
 
 def listf(String directoryName, ArrayList<File> store) {
-    def directory = new File(directoryName);
+    def directory = new File(directoryName)
 
-    def resultList = new ArrayList<File>();
+    def resultList = new ArrayList<File>()
 
-    def fList = directory.listFiles();
-    resultList.addAll(Arrays.asList(fList));
+    def fList = directory.listFiles()
+    resultList.addAll(Arrays.asList(fList))
     for (File file : fList) {
         if (file.isFile()) {
             store.add(file)
@@ -738,7 +695,7 @@ def listf(String directoryName, ArrayList<File> store) {
 }
 
 task buildMetadata(type: BuildToolTask) {
-    def rootPath = "";
+    def rootPath = ""
     if (!findProject(':android-metadata-generator').is(null)) {
         rootPath = Paths.get(project(':android-metadata-generator').projectDir.path, "build/libs").toString()
         dependsOn ':android-metadata-generator:jar'
@@ -761,11 +718,13 @@ task buildMetadata(type: BuildToolTask) {
     // make MDG aware of whitelist.mdg and blacklist.mdg files
     inputs.files(project.fileTree(dir: "$rootDir", include: "**/*.mdg"))
 
-    def classesDir = "$buildDir/intermediates/javac"
-    inputs.dir(classesDir)
+    def classesDir = layout.buildDirectory.dir("intermediates/javac").get().asFile
+    if (classesDir.exists()) {
+        inputs.dir(classesDir)
+    }
 
-    def kotlinClassesDir = "$buildDir/tmp/kotlin-classes"
-    if (file(kotlinClassesDir).exists()) {
+    def kotlinClassesDir = layout.buildDirectory.dir("tmp/kotlin-classes").get().asFile
+    if (kotlinClassesDir.exists()) {
         inputs.dir(kotlinClassesDir)
     }
 
@@ -785,8 +744,8 @@ task buildMetadata(type: BuildToolTask) {
 
         rootProject.subprojects {
 
-          def projectClassesDir = new File("$it.buildDir/intermediates/javac")
-          def projectKotlinClassesDir = new File("$it.buildDir/tmp/kotlin-classes")
+            def projectClassesDir = it.layout.buildDirectory.dir("intermediates/javac").get().asFile
+            def projectKotlinClassesDir = it.layout.buildDirectory.dir("tmp/kotlin-classes").get().asFile
 
             if (projectClassesDir.exists()) {
                 def projectClassesSubDirs = projectClassesDir.listFiles()
@@ -797,14 +756,14 @@ task buildMetadata(type: BuildToolTask) {
                 }
             }
 
-          if (projectKotlinClassesDir.exists()) {
-            def projectKotlinClassesSubDirs = projectKotlinClassesDir.listFiles();
-            for (File subDir : projectKotlinClassesSubDirs) {
-              if (!kotlinClassesSubDirs.contains(subDir)) {
-                kotlinClassesSubDirs.add(subDir)
-              }
+            if (projectKotlinClassesDir.exists()) {
+                def projectKotlinClassesSubDirs = projectKotlinClassesDir.listFiles()
+                for (File subDir : projectKotlinClassesSubDirs) {
+                    if (!kotlinClassesSubDirs.contains(subDir)) {
+                        kotlinClassesSubDirs.add(subDir)
+                    }
+                }
             }
-          }
         }
 
         def generatedClasses = new LinkedList<String>()
@@ -821,7 +780,7 @@ task buildMetadata(type: BuildToolTask) {
         }
 
         def store = new ArrayList<File>()
-        for (String dir: generatedClasses){
+        for (String dir : generatedClasses) {
             listf(dir, store)
         }
 
@@ -846,11 +805,11 @@ task buildMetadata(type: BuildToolTask) {
         def paramz = new ArrayList<String>()
         paramz.add(Paths.get(rootPath, "android-metadata-generator.jar"))
 
-        if(enableAnalytics){
+        if (enableAnalytics) {
             paramz.add("analyticsFilePath=$analyticsFilePath")
         }
 
-        if(enableVerboseMDG){
+        if (enableVerboseMDG) {
             paramz.add("verbose")
         }
 
@@ -912,7 +871,7 @@ static def shouldIncludeDirForTypings(path, includeDirs) {
     return false
 }
 
-task copyTypings {
+task 'copyTypings' {
     doLast {
         outLogger.withStyle(Style.Info).println "Copied generated typings to application root level. Make sure to import android.d.ts in reference.d.ts"
 
@@ -926,12 +885,12 @@ task copyTypings {
 copyTypings.onlyIf { generateTypescriptDefinitions.didWork }
 generateTypescriptDefinitions.finalizedBy(copyTypings)
 
-task validateAppIdMatch {
+task 'validateAppIdMatch' {
     doLast {
         def lineSeparator = System.getProperty("line.separator")
 
         if (project.hasProperty("nsApplicationIdentifier") && !project.hasProperty("release")) {
-            if (project.nsApplicationIdentifier != android.defaultConfig.applicationId) {
+            if (project.nsApplicationIdentifier != android.defaultConfig.applicationId && android.namespace != appIdentifier) {
                 def errorMessage = "${lineSeparator}WARNING: The Application identifier is different from the one inside \"package.json\" file.$lineSeparator" +
                         "NativeScript CLI might not work properly.$lineSeparator" +
                         "Remove applicationId from app.gradle and update the \"nativescript.id\" in package.json.$lineSeparator" +
@@ -970,3 +929,168 @@ task cleanMdg(type: Delete) {
 
 cleanSbg.dependsOn(cleanMdg)
 clean.dependsOn(cleanSbg)
+
+
+tasks.configureEach({ DefaultTask currentTask ->
+  // println "\t ~ [DEBUG][app] build.gradle - currentTask = ${currentTask.name}..."
+    if (currentTask =~ /generate.+BuildConfig/) {
+        currentTask.finalizedBy(extractAllJars)
+        extractAllJars.finalizedBy(collectAllJars)
+    }
+    if (currentTask =~ /compile.+JavaWithJavac/) {
+        currentTask.dependsOn(runSbg)
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /compile.+Kotlin.+/) {
+        currentTask.dependsOn(runSbg)
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /merge.*Assets/) {
+        currentTask.dependsOn(buildMetadata)
+    }
+    // ensure buildMetadata is done before R8 to allow custom proguard from metadata
+    if (currentTask =~ /minify.*WithR8/) {
+        currentTask.dependsOn(buildMetadata)
+    }
+    if (currentTask =~ /assemble.*Debug/ || currentTask =~ /assemble.*Release/) {
+        currentTask.finalizedBy("validateAppIdMatch")
+    }
+
+    if (currentTask =~ /process.+Resources/) {
+        cleanupAllJars.dependsOn(currentTask)
+    }
+
+    if (currentTask =~ /merge.+Shaders/) {
+        currentTask.dependsOn(runSbg)
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /mergeDex.+/) {
+        currentTask.dependsOn(runSbg)
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /dexBuilder.+/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /extract.+NativeSymbolTables/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /mergeExtDex.+/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /mergeLibDex.+/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /mergeProjectDex.+/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /merge.+NativeLibs/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /sync.+LibJars/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask.name == "extractProguardFiles") {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /generate.+LintVitalReportModel/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /lintVitalAnalyze.+/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /extract.+NativeSymbolTables/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /merge.+GlobalSynthetics/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /optimize.+Resources/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /buildCMake.*/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /configureCMake.*/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /validateSigning.*/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /generate.*LintReportModel/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask.name.contains(":runtime:configureCMakeRelWithDebInfo")) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /generate.*AndroidTestResValues/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /generate.*AndroidTestLintModel/) {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /generate.*UnitTestLintModel/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /generate.*UnitTestLintModel/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+
+    if (currentTask =~ /lintAnalyze.*UnitTest/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /process.*JavaRes/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /strip.*DebugSymbols/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /merge.*JavaResource/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask.name == ":runtime:lintAnalyzeDebugAndroidTest" || currentTask.name == ":runtime:lintAnalyzeReleaseAndroidTest") {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask.name == "lintAnalyzeDebug" || currentTask.name == "lintAnalyzeRelease") {
+        buildMetadata.finalizedBy(currentTask)
+    }
+
+    if (currentTask =~ /bundle.*Resources/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+    if (currentTask =~ /compile.*ArtProfile/) {
+        currentTask.finalizedBy(buildMetadata)
+    }
+
+})