@akylas/nativescript-cli 8.7.2

package/vendor/gradle-app/app/gradle-helpers/AnalyticsCollector.gradle

@@ -0,0 +1,48 @@
+import groovy.json.JsonBuilder
+
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.nio.file.Path
+
+class AnalyticsCollector{
+
+    private final String analyticsFilePath
+    private boolean hasUseKotlinPropertyInApp = false
+    private boolean hasKotlinRuntimeClasses = false
+
+    private AnalyticsCollector(String analyticsFilePath){
+        this.analyticsFilePath = analyticsFilePath
+    }
+
+    static AnalyticsCollector withOutputPath(String analyticsFilePath){
+        return new AnalyticsCollector(analyticsFilePath)
+    }
+
+    void markUseKotlinPropertyInApp(boolean useKotlin) {
+        hasUseKotlinPropertyInApp = useKotlin
+    }
+
+    void writeAnalyticsFile() {
+        def jsonBuilder = new JsonBuilder()
+        def kotlinUsageData = new Object()
+        kotlinUsageData.metaClass.hasUseKotlinPropertyInApp = hasUseKotlinPropertyInApp
+        kotlinUsageData.metaClass.hasKotlinRuntimeClasses = hasKotlinRuntimeClasses
+        jsonBuilder(kotlinUsage: kotlinUsageData)
+        def prettyJson = jsonBuilder.toPrettyString()
+
+
+
+        Path statisticsFilePath = Paths.get(analyticsFilePath)
+
+        if (Files.notExists(statisticsFilePath)) {
+            Files.createDirectories(statisticsFilePath.getParent())
+            Files.createFile(statisticsFilePath)
+        }
+
+        Files.write(statisticsFilePath, prettyJson.getBytes(StandardCharsets.UTF_8))
+
+    }
+}
+
+ext.AnalyticsCollector = AnalyticsCollector

package/vendor/gradle-app/app/gradle-helpers/BuildToolTask.gradle

@@ -0,0 +1,50 @@
+import static org.gradle.internal.logging.text.StyledTextOutput.Style
+
+class BuildToolTask extends JavaExec {
+    void setOutputs(def logger) {
+        def logFile = new File("$workingDir/${name}.log")
+        if(logFile.exists()) {
+            logFile.delete()
+        }
+        standardOutput new FileOutputStream(logFile)
+        errorOutput new FailureOutputStream(logger, logFile)
+    }
+}
+
+class FailureOutputStream extends OutputStream {
+    private logger
+    private File logFile
+    private currentLine = ""
+    private firstWrite = true
+    FailureOutputStream(inLogger, inLogFile) {
+        logger = inLogger
+        logFile = inLogFile
+    }
+
+    @Override
+    void write(int i) throws IOException {
+        if(firstWrite) {
+            println ""
+            firstWrite = false
+        }
+        currentLine += String.valueOf((char) i)
+    }
+
+    @Override
+    void flush() {
+        if(currentLine?.trim()) {
+            logger.withStyle(Style.Failure).println currentLine.trim()
+            currentLine = ""
+        }
+    }
+
+    @Override
+    void close() {
+        if(!firstWrite && logFile.exists()) {
+            logger.withStyle(Style.Info).println "Detailed log here: ${logFile.getAbsolutePath()}\n"
+        }
+        super.close()
+    }
+}
+
+ext.BuildToolTask = BuildToolTask

package/vendor/gradle-app/app/gradle-helpers/CustomExecutionLogger.gradle

@@ -0,0 +1,52 @@
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+
+import static org.gradle.internal.logging.text.StyledTextOutput.Style
+def outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
+
+class CustomExecutionLogger extends BuildAdapter implements TaskExecutionListener {
+    private logger
+    private failedTask
+
+    CustomExecutionLogger(passedLogger) {
+        logger = passedLogger
+    }
+
+    void buildStarted(Gradle gradle) {
+        failedTask = null
+    }
+
+    void beforeExecute(Task task) {
+    }
+
+    void afterExecute(Task task, TaskState state) {
+        def failure = state.getFailure()
+        if(failure) {
+            failedTask = task
+        }
+    }
+
+    void buildFinished(BuildResult result) {
+        def failure = result.getFailure()
+        if(failure) {
+            if(failedTask && (failedTask.getClass().getName().contains("BuildToolTask"))) {
+                // the error from this task is already logged
+                return
+            }
+
+            println ""
+            logger.withStyle(Style.FailureHeader).println failure.getMessage()
+
+            def causeException = failure.getCause()
+            while (causeException != null) {
+                failure = causeException
+                causeException = failure.getCause()
+            }
+            if(failure != causeException) {
+                logger.withStyle(Style.Failure).println failure.getMessage()
+            }
+            println ""
+        }
+    }
+}
+
+gradle.useLogger(new CustomExecutionLogger(outLogger))

package/vendor/gradle-app/build.gradle

@@ -0,0 +1,170 @@
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+
+import java.nio.file.Paths
+
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+import groovy.json.JsonSlurper
+import static org.gradle.internal.logging.text.StyledTextOutput.Style
+
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+
+    def initialize = { ->
+        // set up our logger
+        project.ext.outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
+        def userDir = "${rootProject.projectDir}/../.."
+        apply from: "$rootDir/gradle-helpers/user_properties_reader.gradle"
+        apply from: "$rootDir/gradle-helpers/paths.gradle"
+        rootProject.ext.userDefinedGradleProperties = getUserProperties("${getAppResourcesPath(userDir)}/Android")
+
+        loadPropertyFile("$rootDir/additional_gradle.properties")
+        
+        if (rootProject.hasProperty("userDefinedGradleProperties")) {
+            rootProject.ext.userDefinedGradleProperties.each { entry ->
+                def propertyName = entry.getKey()
+                def propertyValue = entry.getValue()
+                project.ext.set(propertyName, propertyValue)
+            }
+        }
+
+        // the build script will not work with previous versions of the CLI (3.1 or earlier)
+        def dependenciesJson = file("$rootDir/dependencies.json")
+        if (!dependenciesJson.exists()) {
+            throw new BuildCancelledException("""
+'dependencies.json' file not found. Check whether the NativeScript CLI has prepared the project beforehand,
+and that your NativeScript version is 3.3, or a more recent one. To build an android project with the current
+version of the {N} CLI install a previous version of the runtime package - 'tns platform add android@3.2'.
+""")
+        }
+
+        project.ext.extractedDependenciesDir = "${project.buildDir}/exploded-dependencies"
+        project.ext.cleanupAllJarsTimestamp = "${project.buildDir}/cleanupAllJars.timestamp"
+        project.ext.extractAllJarsTimestamp = "${project.buildDir}/extractAllJars.timestamp"
+
+
+        project.ext.nativescriptDependencies = new JsonSlurper().parseText(dependenciesJson.text)
+        project.ext.PLATFORMS_ANDROID = "platforms/android"
+        project.ext.USER_PROJECT_ROOT = "$rootDir/../.."
+
+        project.ext.getAppPath = { ->
+            def relativePathToApp = "app"
+            def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+            def nsConfig
+
+            if (nsConfigFile.exists()) {
+                nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+            }
+
+            if (project.hasProperty("appPath")) {
+                // when appPath is passed through -PappPath=/path/to/app
+                // the path could be relative or absolute - either case will work
+                relativePathToApp = appPath
+            } else if (nsConfig != null && nsConfig.appPath != null) {
+                relativePathToApp = nsConfig.appPath
+            }
+
+            project.ext.appPath = Paths.get(USER_PROJECT_ROOT).resolve(relativePathToApp).toAbsolutePath()
+
+            return project.ext.appPath
+        }
+
+        project.ext.getAppResourcesPath = { ->
+            def relativePathToAppResources
+            def absolutePathToAppResources
+            def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+            def nsConfig
+
+            if (nsConfigFile.exists()) {
+                nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+            }
+
+            if (project.hasProperty("appResourcesPath")) {
+                // when appResourcesPath is passed through -PappResourcesPath=/path/to/App_Resources
+                // the path could be relative or absolute - either case will work
+                relativePathToAppResources = appResourcesPath
+                absolutePathToAppResources = Paths.get(USER_PROJECT_ROOT).resolve(relativePathToAppResources).toAbsolutePath()
+            } else if (nsConfig != null && nsConfig.appResourcesPath != null) {
+                relativePathToAppResources = nsConfig.appResourcesPath
+                absolutePathToAppResources = Paths.get(USER_PROJECT_ROOT).resolve(relativePathToAppResources).toAbsolutePath()
+            } else {
+                absolutePathToAppResources = "${getAppPath()}/App_Resources"
+            }
+
+            project.ext.appResourcesPath = absolutePathToAppResources
+
+            return absolutePathToAppResources
+        }
+
+
+    }
+
+    def applyBeforePluginGradleConfiguration = { ->
+        def appResourcesPath = getAppResourcesPath()
+        def pathToBeforePluginGradle = "$appResourcesPath/Android/before-plugins.gradle"
+        def beforePluginGradle = file(pathToBeforePluginGradle)
+        if (beforePluginGradle.exists()) {
+            outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined configuration from ${beforePluginGradle}"
+            apply from: pathToBeforePluginGradle
+        }
+    }
+    
+    def applyBuildScriptConfigurations = { ->
+        def absolutePathToAppResources = getAppResourcesPath()
+        def pathToBuildScriptGradle = "$absolutePathToAppResources/Android/rootbuildscript.gradle"
+        def buildScriptGradle = file(pathToBuildScriptGradle)
+        if (buildScriptGradle.exists()) {
+            outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined root buildscript from ${buildScriptGradle}"
+            apply from: pathToBuildScriptGradle, to: buildscript
+        }
+
+        nativescriptDependencies.each { dep ->
+            def pathToPluginBuildScriptGradle = "$rootDir/${dep.directory}/$PLATFORMS_ANDROID/rootbuildscript.gradle"
+            def pluginBuildScriptGradle = file(pathToPluginBuildScriptGradle)
+            if (pluginBuildScriptGradle.exists()) {
+                outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined rootbuildscript from dependency ${pluginBuildScriptGradle}"
+                apply from: pathToPluginBuildScriptGradle, to: buildscript
+            }
+        }
+    }
+
+    initialize()
+    applyBuildScriptConfigurations()
+    applyBeforePluginGradleConfiguration()
+
+    def computeKotlinVersion = { -> project.hasProperty("kotlinVersion") ? kotlinVersion : "${ns_default_kotlin_version}" }
+    def computeBuildToolsVersion = { -> project.hasProperty("androidBuildToolsVersion") ? androidBuildToolsVersion : "${NS_DEFAULT_ANDROID_BUILD_TOOLS_VERSION}" }
+    def kotlinVersion = computeKotlinVersion()
+    def androidBuildToolsVersion = computeBuildToolsVersion()
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:$androidBuildToolsVersion"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+        classpath "org.codehaus.groovy:groovy-all:3.0.8"
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    beforeEvaluate { project ->
+        if (rootProject.hasProperty("userDefinedGradleProperties")) {
+            rootProject.ext.userDefinedGradleProperties.each { entry ->
+                def propertyName = entry.getKey()
+                def propertyValue = entry.getValue()
+                project.ext.set(propertyName, propertyValue)
+            }
+        }
+
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

package/vendor/gradle-app/settings.gradle

@@ -0,0 +1,78 @@
+rootProject.name = "__PROJECT_NAME__"
+include ':app'//, ':runtime', ':runtime-binding-generator'
+
+//project(':runtime').projectDir = new File("${System.env.ANDROID_RUNTIME_HOME}/test-app/runtime")
+//project(':runtime-binding-generator').projectDir = new File("${System.env.ANDROID_RUNTIME_HOME}/test-app/runtime-binding-generator")
+
+file("google-services.json").renameTo(file("./app/google-services.json"))
+
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+
+import java.nio.file.Paths
+
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+import groovy.json.JsonSlurper
+import static org.gradle.internal.logging.text.StyledTextOutput.Style
+
+def USER_PROJECT_ROOT = "$rootDir/../../"
+def outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
+def ext  = {
+    appResourcesPath = getProperty("appResourcesPath")
+    appPath = getProperty("appPath")
+}
+
+def getAppPath = { ->
+      def relativePathToApp = "app"
+      def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+      def nsConfig
+
+      if (nsConfigFile.exists()) {
+          nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+      }
+
+      if (ext.appPath) {
+          // when appPath is passed through -PappPath=/path/to/app
+          // the path could be relative or absolute - either case will work
+          relativePathToApp = ext.appPath
+      } else if (nsConfig != null && nsConfig.appPath != null) {
+          relativePathToApp = nsConfig.appPath
+      }
+
+      return Paths.get(USER_PROJECT_ROOT).resolve(relativePathToApp).toAbsolutePath()
+  }
+
+
+def getAppResourcesPath = { ->
+    def relativePathToAppResources
+    def absolutePathToAppResources
+    def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+    def nsConfig
+
+    if (nsConfigFile.exists()) {
+        nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+    }
+    if (ext.appResourcesPath) {
+        // when appResourcesPath is passed through -PappResourcesPath=/path/to/App_Resources
+        // the path could be relative or absolute - either case will work
+        relativePathToAppResources = ext.appResourcesPath
+        absolutePathToAppResources = Paths.get(USER_PROJECT_ROOT).resolve(relativePathToAppResources).toAbsolutePath()
+    } else if (nsConfig != null && nsConfig.appResourcesPath != null) {
+        relativePathToAppResources = nsConfig.appResourcesPath
+        absolutePathToAppResources = Paths.get(USER_PROJECT_ROOT).resolve(relativePathToAppResources).toAbsolutePath()
+    } else {
+        absolutePathToAppResources = "${getAppPath()}/App_Resources"
+    }
+    return absolutePathToAppResources
+}
+
+def applySettingsGradleConfiguration = { ->
+        def appResourcesPath = getAppResourcesPath()
+        def pathToSettingsGradle = "$appResourcesPath/Android/settings.gradle"
+        def settingsGradle = file(pathToSettingsGradle)
+        if (settingsGradle.exists()) {
+            outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined configuration from ${settingsGradle}"
+            apply from: pathToSettingsGradle
+        }
+}
+
+applySettingsGradleConfiguration()