@akylas/nativescript-cli 8.7.2

package/vendor/gradle-plugin/build.gradle

@@ -0,0 +1,363 @@
+import groovy.json.JsonSlurper
+import org.gradle.internal.logging.text.StyledTextOutputFactory
+import static org.gradle.internal.logging.text.StyledTextOutput.Style
+import java.nio.file.Paths
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-parcelize'
+
+def loadPropertyFile = { path ->
+    try {
+        if(project.hasProperty("loadedProperties_${path}")) {
+            logger.info "\t + gradle properties already loaded. SKIPPING"
+        } else {
+            logger.info "\t + trying to load gradle properties from \"$path\""
+
+            Properties properties = new Properties()
+            properties.load(new FileInputStream("$path"))
+            properties.each { prop ->
+                logger.info "\t + [$path] setting ${prop.key} = ${prop.value}"
+                project.ext.set(prop.key, prop.value)
+            }
+            project.ext.set("loadedProperties_${path}", true)
+            
+            outLogger.withStyle(Style.SuccessHeader).println "\t + loaded gradle properties from \"$path\""
+        }
+    } catch(Exception ex) {
+        logger.warn "\t + failed to load gradle properties from \"$path\". Error is: ${ex.getMessage()}"
+    }
+}
+
+buildscript {
+    def GRADLE_PROPERTIES_FILENAME = "gradle.properties"
+
+    def getFile = { dir, filename ->
+        File file = new File("$dir$File.separator$filename")
+        file?.exists() ? file : null
+    }
+
+    def getPropertyFile = { dir ->
+        return getFile(dir, GRADLE_PROPERTIES_FILENAME)
+    }
+    def getUserProperties = { dir ->
+        def file = getPropertyFile(dir)
+        if (!file) {
+            return null
+        }
+
+        Properties properties = new Properties()
+        properties.load(file.newInputStream())
+
+        return properties
+    }
+    def loadPropertyFile = { path ->
+        try {
+            if(project.hasProperty("loadedProperties_${path}")) {
+                logger.info "\t + gradle properties already loaded. SKIPPING"
+            } else {
+                logger.info "\t + trying to load gradle properties from \"$path\""
+
+                Properties properties = new Properties()
+                properties.load(new FileInputStream("$path"))
+                properties.each { prop ->
+                    logger.info "\t + [$path] setting ${prop.key} = ${prop.value}"
+                    project.ext.set(prop.key, prop.value)
+                }
+                project.ext.set("loadedProperties_${path}", true)
+                
+                outLogger.withStyle(Style.SuccessHeader).println "\t + loaded gradle properties from \"$path\""
+            }
+        } catch(Exception ex) {
+            logger.warn "\t + failed to load gradle properties from \"$path\". Error is: ${ex.getMessage()}"
+        }
+    }
+    
+
+    project.ext.getAppPath = { ->
+        // def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+        // def nsConfig
+
+        // if (nsConfigFile.exists()) {
+        //     nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+        // }
+        def relativePathToApp = "app"
+        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.getBuildPath = { ->
+        // def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+        // def nsConfig
+
+        // if (nsConfigFile.exists()) {
+        //     nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+        // }
+        def relativeBuildToApp = "platforms"
+        if (project.getProperty("appBuildPath")) {
+            relativeBuildToApp = appBuildPath
+        // } else if (nsConfig != null && nsConfig.buildPath != null) {
+        //     relativeBuildToApp = nsConfig.buildPath
+        }
+        project.ext.relativeBuildPath = relativeBuildToApp
+        project.ext.buildPath = Paths.get(USER_PROJECT_ROOT).resolve(relativeBuildToApp).toAbsolutePath()
+        return project.ext.relativeBuildPath
+    }
+    project.ext.getAppResourcesPath = { ->
+        // def nsConfigFile = file("$USER_PROJECT_ROOT/nsconfig.json")
+        // def nsConfig
+
+        // if (nsConfigFile.exists()) {
+        //     nsConfig = new JsonSlurper().parseText(nsConfigFile.getText("UTF-8"))
+        // }
+        def relativePathToAppResources
+        def absolutePathToAppResources
+
+        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 = "${project.ext.getAppPath()}/App_Resources"
+        }
+
+        project.ext.appResourcesPath = absolutePathToAppResources
+
+        return absolutePathToAppResources
+    }
+
+    project.ext.applyBeforePluginGradleConfiguration = { ->
+        def appResourcesPath = project.ext.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 initialize = { ->
+        // set up our logger
+        project.ext.outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
+        outLogger.withStyle(Style.SuccessHeader).println "\t ~initialize"
+
+
+        project.ext.USER_PROJECT_ROOT = "$rootDir/../.."
+        if (project.hasProperty('projectRoot')) {
+            project.ext.USER_PROJECT_ROOT = projectRoot
+        }
+        project.ext.PLATFORMS_ANDROID = project.ext.getBuildPath() + "/android"
+        project.ext.PLUGIN_NAME = "{{pluginName}}"
+        
+        def userDir = "$USER_PROJECT_ROOT"
+        rootProject.ext.userDefinedGradleProperties = getUserProperties("${project.ext.getAppResourcesPath()}/Android")
+
+        loadPropertyFile("$USER_PROJECT_ROOT/${project.ext.PLATFORMS_ANDROID}/gradle.properties")
+        loadPropertyFile("$USER_PROJECT_ROOT/${project.ext.PLATFORMS_ANDROID}/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)
+            }
+        }
+
+        def getDepPlatformDir = { dep ->
+            file("${project.ext.USER_PROJECT_ROOT}/${project.ext.PLATFORMS_ANDROID}/${dep.directory}/platforms/android")
+        }
+
+        // Set up styled logger
+        project.ext.getDepPlatformDir = getDepPlatformDir
+        project.ext.outLogger = services.get(StyledTextOutputFactory).create("colouredOutputLogger")
+
+
+        // the build script will not work with previous versions of the CLI (3.1 or earlier)
+        def dependenciesJson = file("${project.ext.USER_PROJECT_ROOT}/${project.ext.PLATFORMS_ANDROID}/dependencies.json")
+        def appDependencies = new JsonSlurper().parseText(dependenciesJson.text)
+        def pluginData = appDependencies.find { it.name == project.ext.PLUGIN_NAME }
+        project.ext.nativescriptDependencies = appDependencies.findAll{pluginData.dependencies.contains(it.name)}.plus([pluginData])
+    }
+    def applyBuildScriptConfigurations = { ->
+        def absolutePathToAppResources = project.ext.getAppResourcesPath()
+        def pathToBuildScriptGradle = "$absolutePathToAppResources/Android/buildscript.gradle"
+        def buildScriptGradle = file(pathToBuildScriptGradle)
+        if (buildScriptGradle.exists()) {
+            outLogger.withStyle(Style.SuccessHeader).println "\t ~ applying user-defined buildscript from ${buildScriptGradle}"
+            apply from: pathToBuildScriptGradle, to: buildscript
+        }
+
+        nativescriptDependencies.each { dep ->
+            def pathToPluginBuildScriptGradle = "${getDepPlatformDir(dep)}/buildscript.gradle"
+            def pluginBuildScriptGradle = file(pathToPluginBuildScriptGradle)
+            if (pluginBuildScriptGradle.exists()) {
+                outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined buildscript from dependency ${pluginBuildScriptGradle}"
+                apply from: pathToPluginBuildScriptGradle, to: buildscript
+            }
+            // def pathToPluginProjectBuildScriptGradle = "${getDepPlatformDir(dep)}/project-buildscript.gradle"
+            // def pluginProjectBuildScriptGradle = file(pathToPluginProjectBuildScriptGradle)
+            // if (pluginProjectBuildScriptGradle.exists()) {
+            //     outLogger.withStyle(Style.SuccessHeader).println "\t + applying user-defined project-buildscript from dependency ${pluginProjectBuildScriptGradle}"
+            //     apply from: pathToPluginProjectBuildScriptGradle, to: project
+            // }
+        }
+
+        def pathToPluginBuildScriptGradle = "$rootDir/buildscript.gradle"
+        def pluginBuildScriptGradle = file(pathToPluginBuildScriptGradle)
+        if (pluginBuildScriptGradle.exists()) {
+            outLogger.withStyle(Style.SuccessHeader).println "\t ~ applying user-defined buildscript from dependency ${pluginBuildScriptGradle}"
+            apply from: pathToPluginBuildScriptGradle, to: buildscript
+        }
+    }
+
+    initialize()
+    project.ext.applyBeforePluginGradleConfiguration()
+    applyBuildScriptConfigurations()
+
+    def computeKotlinVersion = { -> project.hasProperty("kotlinVersion") ? kotlinVersion : "${ns_default_kotlin_version}" }
+    def computeBuildToolsVersion = { -> project.hasProperty("androidBuildToolsVersion") ? androidBuildToolsVersion : "{{runtimeAndroidPluginVersion}}" }
+    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"
+    }
+
+}
+
+def pluginDependencies
+
+allprojects {
+    repositories {
+        // used for local *.AAR files
+        pluginDependencies = nativescriptDependencies.collect {
+            getDepPlatformDir(it)
+        }
+
+        // some plugins may have their android dependencies in a /libs subdirectory
+        pluginDependencies.addAll(nativescriptDependencies.collect {
+            "${getDepPlatformDir(it)}/libs"
+        })
+        mavenLocal()
+        mavenCentral()
+        maven {
+            url 'https://maven.google.com/'
+            name 'Google'
+        }
+        jcenter()
+        if (pluginDependencies.size() > 0) {
+            flatDir {
+                dirs pluginDependencies
+            }
+        }
+    }
+}
+
+android {
+    namespace "{{pluginNamespace}}"
+    def applyPluginGradleConfigurations = { ->
+        nativescriptDependencies.each { dep ->
+            def includeGradlePath = "${getDepPlatformDir(dep)}/include.gradle"
+            if (file(includeGradlePath).exists()) {
+                outLogger.withStyle(Style.SuccessHeader).println "\t + applying plugin include.gradle from dependency ${includeGradlePath}"
+                apply from: includeGradlePath
+            }
+        }
+    }
+
+    def computeCompileSdkVersion = { -> project.hasProperty("compileSdk") ? project.compileSdk : 31 }
+    def computeTargetSdkVersion = { -> project.hasProperty("targetSdk") ? project.targetSdk : 31 as int }
+    def computeBuildToolsVersion = { ->
+        project.hasProperty("buildToolsVersion") ? project.buildToolsVersion : "31.0.0"
+    }
+
+    project.ext.applyBeforePluginGradleConfiguration()
+    applyPluginGradleConfigurations()
+
+    compileSdkVersion computeCompileSdkVersion()
+    buildToolsVersion computeBuildToolsVersion()
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    if (project.hasProperty("ndkVersion")) {
+        ndkVersion project.ndkVersion
+    }
+
+    defaultConfig {
+        targetSdkVersion computeTargetSdkVersion()
+        versionCode 1
+        versionName "1.0"
+    }
+    lintOptions {
+        checkReleaseBuilds false
+        abortOnError false
+    }
+}
+
+task addDependenciesFromNativeScriptPlugins {
+    nativescriptDependencies.each { dep ->
+        def aarFiles = fileTree(dir: getDepPlatformDir(dep), include: ["**/*.aar"])
+        def currentDirname = file(project.buildscript.sourceFile).getParentFile().getName()
+        aarFiles.each { aarFile ->
+            def length = aarFile.name.length() - 4
+            def fileName = aarFile.name[0..<length]
+            if(fileName == currentDirname) {
+                return
+            }
+            outLogger.withStyle(Style.SuccessHeader).println "\t + adding aar plugin dependency: " + aarFile.getAbsolutePath()
+            project.dependencies.add("implementation", [name: fileName, ext: "aar"])
+        }
+
+        def jarFiles = fileTree(dir: getDepPlatformDir(dep), include: ["*.jar"])
+        jarFiles.each { jarFile ->
+            def jarFileAbsolutePath = jarFile.getAbsolutePath()
+            outLogger.withStyle(Style.SuccessHeader).println "\t + adding jar plugin dependency: $jarFileAbsolutePath"
+            // pluginsJarLibraries.add(jarFile.getAbsolutePath())
+        }
+
+        project.dependencies.add("implementation", jarFiles)
+    }
+}
+
+// This wont work with gradle 8 + should be the same as the code  just after
+// afterEvaluate {
+//     def generateBuildConfig =  project.hasProperty("generateBuildConfig") ? project.generateBuildConfig : false
+//     def generateR =  project.hasProperty("generateR") ? project.generateR : false
+//     generateReleaseBuildConfig.enabled = generateBuildConfig
+//     generateDebugBuildConfig.enabled = generateBuildConfig
+//     generateReleaseResValues.enabled = generateR
+//     generateDebugResValues.enabled = generateR
+// }
+project.tasks.configureEach {
+    if (name == 'bundleRelease') {
+        def generateBuildConfig =  project.hasProperty("generateBuildConfig") ? project.generateBuildConfig : false
+        def generateR =  project.hasProperty("generateR") ? project.generateR : false
+        if (!generateBuildConfig) {
+            it.exclude '**/BuildConfig.class'
+        }
+        if (!generateR) {
+            it.exclude '**/R.class', '**/R$*.class'
+        }
+    }
+}

package/vendor/gradle-plugin/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Fri May 11 16:45:47 EEST 2018
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-{{runtimeGradleVersion}}-bin.zip

package/vendor/gradle-plugin/gradle.properties

@@ -0,0 +1,6 @@
+# Nativescript CLI plugin build gradle properties
+org.gradle.jvmargs=-Xmx16384M
+
+android.enableJetifier=true
+android.useAndroidX=true
+android.nonTransitiveRClass=true

package/vendor/gradle-plugin/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save ( ) {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

package/vendor/gradle-plugin/gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

package/vendor/gradle-plugin/settings.gradle

@@ -0,0 +1,45 @@
+import groovy.json.JsonSlurper
+
+
+def getProjectRoot = { ->
+    def projectRoot = "$rootDir/../../"
+    if (System.getProperties().projectRoot != null) {
+        projectRoot = System.getProperties().projectRoot
+    }
+    return projectRoot
+}
+
+def getBuildPath = { ->
+    def relativeBuildToApp = "platforms"
+    if (System.getProperties().appBuildPath != null) {
+        relativeBuildToApp = System.getProperties().appBuildPath
+    }
+    return relativeBuildToApp
+}
+
+def USER_PROJECT_ROOT = getProjectRoot()
+def PLATFORMS_ANDROID = getBuildPath() + "/android"
+def PLUGIN_NAME = "{{pluginName}}"
+
+
+
+def dependenciesJson = file("${USER_PROJECT_ROOT}/${PLATFORMS_ANDROID}/dependencies.json")
+def appDependencies = new JsonSlurper().parseText(dependenciesJson.text)
+def pluginData = appDependencies.find { it.name == PLUGIN_NAME }
+def nativescriptDependencies = appDependencies.findAll{pluginData.name == it.name}
+
+def getDepPlatformDir = { dep ->
+        file("$USER_PROJECT_ROOT/$PLATFORMS_ANDROID/${dep.directory}/$PLATFORMS_ANDROID")
+}
+
+
+def applyIncludeSettingsGradlePlugin = {
+     nativescriptDependencies.each { dep ->
+            def includeSettingsGradlePath = "${getDepPlatformDir(dep)}/include-settings.gradle"
+            if (file(includeSettingsGradlePath).exists()) {
+                apply from: includeSettingsGradlePath
+            }
+    }
+}
+
+applyIncludeSettingsGradlePlugin()