nativescript 9.0.0-alpha.9 → 9.0.0-dev.0

package/lib/project-data.js

@@ -75,14 +75,14 @@ class ProjectData {
                 nsConfig && nsConfig.projectName
                     ? nsConfig.projectName
                     : this.$projectHelper.sanitizeName(path.basename(projectDir));
-            this.platformsDir = path.join(projectDir, constants.PLATFORMS_DIR_NAME);
+            this.nsConfig = nsConfig;
+            this.platformsDir = path.join(projectDir, this.getBuildRelativeDirectoryPath());
             this.projectFilePath = projectFilePath;
             this.projectIdentifiers = this.initializeProjectIdentifiers(nsConfig);
             this.packageJsonData = packageJsonData;
             this.dependencies = packageJsonData.dependencies;
             this.devDependencies = packageJsonData.devDependencies;
             this.projectType = this.getProjectType();
-            this.nsConfig = nsConfig;
             this.ignoredDependencies = nsConfig === null || nsConfig === void 0 ? void 0 : nsConfig.ignoredNativeDependencies;
             this.appDirectoryPath = this.getAppDirectoryPath();
             this.appResourcesDirectoryPath = this.getAppResourcesDirectoryPath();
@@ -136,6 +136,12 @@ class ProjectData {
         const appRelativePath = this.getAppDirectoryRelativePath();
         return this.resolveToProjectDir(appRelativePath, projectDir);
     }
+    getBuildRelativeDirectoryPath() {
+        if (this.nsConfig && this.nsConfig[constants.CONFIG_NS_BUILD_ENTRY]) {
+            return this.nsConfig[constants.CONFIG_NS_BUILD_ENTRY];
+        }
+        return constants.PLATFORMS_DIR_NAME;
+    }
     getAppDirectoryRelativePath() {
         if (this.nsConfig && this.nsConfig[constants.CONFIG_NS_APP_ENTRY]) {
             return this.nsConfig[constants.CONFIG_NS_APP_ENTRY];

package/lib/services/analytics/analytics-broker-process.js

@@ -44,7 +44,7 @@ process.on("message", async (data) => {
             analyticsLoggingService.logData({
                 message: `analytics-broker-process will send ${"ProcessFinishedTasks"} message`,
             });
-            process.send("ProcessFinishedTasks", () => {
+            process.send("ProcessFinishedTasks", null, null, () => {
                 analyticsLoggingService.logData({
                     message: `analytics-broker-process sent ${"ProcessFinishedTasks"} message and will exit gracefully now`,
                 });

package/lib/services/analytics/analytics-service.js

@@ -38,7 +38,7 @@ class AnalyticsService {
             if ((await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) &&
                 (0, helpers_1.isInteractive)()) {
                 const message = `Do you want to help us improve ${this.$analyticsSettingsService.getClientName()} by automatically sending anonymous usage statistics? We will not use this information to identify or contact you.`;
-                trackFeatureUsage = await this.$prompter.confirm(message, () => true);
+                trackFeatureUsage = await this.$prompter.confirm(message, () => false);
                 await this.setStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, trackFeatureUsage);
                 await this.trackAcceptFeatureUsage({
                     acceptTrackFeatureUsage: trackFeatureUsage,

package/lib/services/android/gradle-build-args-service.js

@@ -5,7 +5,8 @@ const path = require("path");
 const constants_1 = require("../../common/constants");
 const yok_1 = require("../../common/yok");
 class GradleBuildArgsService {
-    constructor($hooksService, $analyticsService, $staticConfig, $projectData, $logger) {
+    constructor($androidToolsInfo, $hooksService, $analyticsService, $staticConfig, $projectData, $logger) {
+        this.$androidToolsInfo = $androidToolsInfo;
         this.$hooksService = $hooksService;
         this.$analyticsService = $analyticsService;
         this.$staticConfig = $staticConfig;
@@ -30,10 +31,18 @@ class GradleBuildArgsService {
     }
     getBaseTaskArgs(buildData) {
         const args = this.getBuildLoggingArgs();
+        const toolsInfo = this.$androidToolsInfo.getToolsInfo({
+            projectDir: buildData.projectDir,
+        });
         this.$projectData.initializeProjectData(buildData.projectDir);
-        args.push(`-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
-        if (buildData.gradleArgs) {
-            args.push(buildData.gradleArgs);
+        args.push(`--stacktrace`, `-PcompileSdk=${toolsInfo.compileSdkVersion}`, `-PtargetSdk=${toolsInfo.targetSdkVersion}`, `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`, `-PgenerateTypings=${toolsInfo.generateTypings}`, `-PprojectRoot=${this.$projectData.projectDir}`, `-DprojectRoot=${this.$projectData.projectDir}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-DappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
+        const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || []).concat(buildData.gradleArgs || []);
+        if (gradleArgs) {
+            const additionalArgs = [];
+            gradleArgs.forEach((arg) => {
+                additionalArgs.push(...arg.split(" ").map((a) => a.trim()));
+            });
+            args.push(...additionalArgs);
         }
         if (buildData.release) {
             args.push("-Prelease", `-PksPath=${path.resolve(buildData.keyStorePath)}`, `-Palias=${buildData.keyStoreAlias}`, `-Ppassword=${buildData.keyStoreAliasPassword}`, `-PksPassword=${buildData.keyStorePassword}`);
@@ -44,15 +53,20 @@ class GradleBuildArgsService {
         const args = [];
         const logLevel = this.$logger.getLevel();
         if (logLevel === "TRACE") {
-            args.push("--stacktrace", "--debug");
+            args.push("--debug");
         }
         else if (logLevel === "INFO") {
-            args.push("--quiet");
+            args.push("--info");
         }
         return args;
     }
     getBuildTaskName(buildData) {
-        const baseTaskName = buildData.androidBundle ? "bundle" : "assemble";
+        let baseTaskName = buildData.androidBundle ? "bundle" : "assemble";
+        if (buildData.gradleFlavor) {
+            baseTaskName +=
+                buildData.gradleFlavor[0].toUpperCase() +
+                    buildData.gradleFlavor.slice(1);
+        }
         const buildTaskName = buildData.release
             ? `${baseTaskName}${constants_1.Configurations.Release}`
             : `${baseTaskName}${constants_1.Configurations.Debug}`;

package/lib/services/android/gradle-build-service.js

@@ -6,14 +6,28 @@ const constants = require("../../constants");
 const events_1 = require("events");
 const yok_1 = require("../../common/yok");
 class GradleBuildService extends events_1.EventEmitter {
-    constructor($childProcess, $gradleBuildArgsService, $gradleCommandService) {
+    constructor($childProcess, $gradleBuildArgsService, $gradleCommandService, $devicesService) {
         super();
         this.$childProcess = $childProcess;
         this.$gradleBuildArgsService = $gradleBuildArgsService;
         this.$gradleCommandService = $gradleCommandService;
+        this.$devicesService = $devicesService;
     }
     async buildProject(projectRoot, buildData) {
         const buildTaskArgs = await this.$gradleBuildArgsService.getBuildTaskArgs(buildData);
+        if (buildData.buildFilterDevicesArch) {
+            let devices = this.$devicesService.getDevicesForPlatform(buildData.platform);
+            if (buildData.emulator) {
+                devices = devices.filter((d) => d.isEmulator);
+            }
+            const abis = devices
+                .map((d) => d.deviceInfo.abis.filter((a) => !!a && a.length)[0])
+                .filter((a) => !!a);
+            if (abis.length > 0 &&
+                buildTaskArgs.findIndex((b) => b.startsWith("-PabiFilters")) === -1) {
+                buildTaskArgs.push(`-PabiFilters=${abis.join(",")}`);
+            }
+        }
         const spawnOptions = {
             emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
             throwError: true,

package/lib/services/android-plugin-build-service.js

@@ -19,9 +19,10 @@ class AndroidPluginBuildService {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    constructor($fs, $childProcess, $hostInfo, $options, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
+    constructor($fs, $childProcess, $androidToolsInfo, $hostInfo, $options, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
         this.$fs = $fs;
         this.$childProcess = $childProcess;
+        this.$androidToolsInfo = $androidToolsInfo;
         this.$hostInfo = $hostInfo;
         this.$options = $options;
         this.$logger = $logger;
@@ -89,22 +90,6 @@ class AndroidPluginBuildService {
         }));
         return promise;
     }
-    getIncludeGradleCompileDependenciesScope(includeGradleFileContent) {
-        const indexOfDependenciesScope = includeGradleFileContent.indexOf("dependencies");
-        const result = [];
-        if (indexOfDependenciesScope === -1) {
-            return result;
-        }
-        const indexOfRepositoriesScope = includeGradleFileContent.indexOf("repositories");
-        let repositoriesScope = "";
-        if (indexOfRepositoriesScope >= 0) {
-            repositoriesScope = this.getScope("repositories", includeGradleFileContent);
-            result.push(repositoriesScope);
-        }
-        const dependenciesScope = this.getScope("dependencies", includeGradleFileContent);
-        result.push(dependenciesScope);
-        return result;
-    }
     getScope(scopeName, content) {
         const indexOfScopeName = content.indexOf(scopeName);
         const openingBracket = "{";
@@ -136,7 +121,7 @@ class AndroidPluginBuildService {
         this.validateOptions(options);
         const manifestFilePath = this.getManifest(options.platformsAndroidDirPath);
         const androidSourceDirectories = this.getAndroidSourceDirectories(options.platformsAndroidDirPath);
-        const shortPluginName = (0, helpers_1.getShortPluginName)(options.pluginName);
+        const shortPluginName = (0, helpers_1.getShortPluginName)(options.pluginName + (options.aarSuffix || ''));
         const pluginTempDir = path.join(options.tempPluginDirPath, shortPluginName);
         const pluginSourceFileHashesInfo = await this.getSourceFilesHashes(options.platformsAndroidDirPath, shortPluginName);
         const shouldBuildAar = await this.shouldBuildAar({
@@ -153,9 +138,10 @@ class AndroidPluginBuildService {
             await this.updateManifest(manifestFilePath, pluginTempMainSrcDir, shortPluginName);
             this.copySourceSetDirectories(androidSourceDirectories, pluginTempMainSrcDir);
             await this.setupGradle(pluginTempDir, options.platformsAndroidDirPath, options.projectDir, options.pluginName);
+            const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || []).concat(options.gradleArgs || []);
             await this.buildPlugin({
                 gradlePath: options.gradlePath,
-                gradleArgs: options.gradleArgs,
+                gradleArgs,
                 pluginDir: pluginTempDir,
                 pluginName: options.pluginName,
                 projectDir: options.projectDir,
@@ -228,16 +214,37 @@ class AndroidPluginBuildService {
             this.$fs.copyFile(path.join(dir, "*"), destination);
         }
     }
+    extractNamespaceFromManifest(manifestPath) {
+        const fileContent = this.$fs.readText(manifestPath);
+        const contentRegex = new RegExp('package="(.*?)"');
+        const match = fileContent.match(contentRegex);
+        let namespace;
+        if (match) {
+            namespace = match[1];
+            const replacedFileContent = fileContent.replace(contentRegex, "");
+            this.$fs.writeFile(manifestPath, replacedFileContent);
+        }
+        return namespace;
+    }
     async setupGradle(pluginTempDir, platformsAndroidDirPath, projectDir, pluginName) {
         const gradleTemplatePath = path.resolve(path.join(__dirname, "../../vendor/gradle-plugin"));
         const allGradleTemplateFiles = path.join(gradleTemplatePath, "*");
         const buildGradlePath = path.join(pluginTempDir, "build.gradle");
         const settingsGradlePath = path.join(pluginTempDir, "settings.gradle");
         this.$fs.copyFile(allGradleTemplateFiles, pluginTempDir);
-        this.addCompileDependencies(platformsAndroidDirPath, buildGradlePath);
         const runtimeGradleVersions = await this.getRuntimeGradleVersions(projectDir);
-        this.replaceGradleVersion(pluginTempDir, runtimeGradleVersions.gradleVersion);
+        let gradleVersion = runtimeGradleVersions.gradleVersion;
+        if (this.$projectData.nsConfig.android.gradleVersion) {
+            gradleVersion = this.$projectData.nsConfig.android.gradleVersion;
+        }
+        this.replaceGradleVersion(pluginTempDir, gradleVersion);
         this.replaceGradleAndroidPluginVersion(buildGradlePath, runtimeGradleVersions.gradleAndroidPluginVersion);
+        const manifestFilePath = this.getManifest(path.join(pluginTempDir, "src", "main"));
+        let pluginNamespace = this.extractNamespaceFromManifest(manifestFilePath);
+        if (!pluginNamespace) {
+            pluginNamespace = pluginName.replace(/@/g, "").replace(/[/-]/g, ".");
+        }
+        this.replaceFileContent(buildGradlePath, "{{pluginNamespace}}", pluginNamespace);
         this.replaceFileContent(buildGradlePath, "{{pluginName}}", pluginName);
         this.replaceFileContent(settingsGradlePath, "{{pluginName}}", pluginName);
         const shortPluginName = (0, helpers_1.getShortPluginName)(pluginName);
@@ -269,24 +276,27 @@ class AndroidPluginBuildService {
         return runtimeGradleVersions || {};
     }
     async getLatestRuntimeVersion() {
-        var _a;
+        var _a, _b;
         let runtimeVersion = null;
+        const packageName = ((_a = this.$projectData.nsConfig.android) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants_1.SCOPED_ANDROID_RUNTIME_NAME;
         try {
-            let result = await this.$packageManager.view(constants_1.SCOPED_ANDROID_RUNTIME_NAME, {
+            let result = await this.$packageManager.view(packageName, {
                 "dist-tags": true,
             });
-            result = (_a = result === null || result === void 0 ? void 0 : result["dist-tags"]) !== null && _a !== void 0 ? _a : result;
+            result = (_b = result === null || result === void 0 ? void 0 : result["dist-tags"]) !== null && _b !== void 0 ? _b : result;
             runtimeVersion = result.latest;
         }
         catch (err) {
             this.$logger.trace(`Error while getting latest android runtime version from view command: ${err}`);
-            const registryData = await this.$packageManager.getRegistryPackageData(constants_1.SCOPED_ANDROID_RUNTIME_NAME);
+            const registryData = await this.$packageManager.getRegistryPackageData(packageName);
             runtimeVersion = registryData["dist-tags"].latest;
         }
         return runtimeVersion;
     }
     getLocalGradleVersions() {
-        const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(constants_1.SCOPED_ANDROID_RUNTIME_NAME, {
+        var _a;
+        const packageName = ((_a = this.$projectData.nsConfig.android) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants_1.SCOPED_ANDROID_RUNTIME_NAME;
+        const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(packageName, {
             paths: [this.$projectData.projectDir],
         });
         if (!installedRuntimePackageJSONPath) {
@@ -313,18 +323,19 @@ class AndroidPluginBuildService {
         return null;
     }
     async getGradleVersions(runtimeVersion) {
-        var _a, _b;
+        var _a, _b, _c;
         let runtimeGradleVersions = null;
         const localVersionInfo = this.getLocalGradleVersions();
         if (localVersionInfo) {
             return localVersionInfo;
         }
+        const packageName = ((_a = this.$projectData.nsConfig.android) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants_1.SCOPED_ANDROID_RUNTIME_NAME;
         try {
-            let output = await this.$packageManager.view(`${constants_1.SCOPED_ANDROID_RUNTIME_NAME}@${runtimeVersion}`, { version_info: true });
-            output = (_a = output === null || output === void 0 ? void 0 : output["version_info"]) !== null && _a !== void 0 ? _a : output;
+            let output = await this.$packageManager.view(`${packageName}@${runtimeVersion}`, { version_info: true });
+            output = (_b = output === null || output === void 0 ? void 0 : output["version_info"]) !== null && _b !== void 0 ? _b : output;
             if (!output) {
-                output = await this.$packageManager.view(`${constants_1.SCOPED_ANDROID_RUNTIME_NAME}@${runtimeVersion}`, { gradle: true });
-                output = (_b = output === null || output === void 0 ? void 0 : output["gradle"]) !== null && _b !== void 0 ? _b : output;
+                output = await this.$packageManager.view(`${packageName}@${runtimeVersion}`, { gradle: true });
+                output = (_c = output === null || output === void 0 ? void 0 : output["gradle"]) !== null && _c !== void 0 ? _c : output;
                 const { version, android } = output;
                 output = {
                     gradle: version,
@@ -335,7 +346,7 @@ class AndroidPluginBuildService {
         }
         catch (err) {
             this.$logger.trace(`Error while getting gradle data for android runtime from view command: ${err}`);
-            const registryData = await this.$packageManager.getRegistryPackageData(constants_1.SCOPED_ANDROID_RUNTIME_NAME);
+            const registryData = await this.$packageManager.getRegistryPackageData(packageName);
             runtimeGradleVersions = registryData.versions[runtimeVersion];
         }
         const result = this.getGradleVersionsCore(runtimeGradleVersions);
@@ -370,16 +381,6 @@ class AndroidPluginBuildService {
         const replacedFileContent = fileContent.replace(contentRegex, replacement);
         this.$fs.writeFile(filePath, replacedFileContent);
     }
-    addCompileDependencies(platformsAndroidDirPath, buildGradlePath) {
-        const includeGradlePath = path.join(platformsAndroidDirPath, constants_1.INCLUDE_GRADLE_NAME);
-        if (this.$fs.exists(includeGradlePath)) {
-            const includeGradleContent = this.$fs.readText(includeGradlePath);
-            const compileDependencies = this.getIncludeGradleCompileDependenciesScope(includeGradleContent);
-            if (compileDependencies.length) {
-                this.$fs.appendFile(buildGradlePath, "\n" + compileDependencies.join("\n"));
-            }
-        }
-    }
     copyAar(shortPluginName, pluginTempDir, aarOutputDir) {
         const finalAarName = `${shortPluginName}-release.aar`;
         const pathToBuiltAar = path.join(pluginTempDir, "build", "outputs", "aar", finalAarName);
@@ -428,19 +429,32 @@ class AndroidPluginBuildService {
     async buildPlugin(pluginBuildSettings) {
         var _a;
         const gradlew = (_a = pluginBuildSettings.gradlePath) !== null && _a !== void 0 ? _a : (this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew");
+        const toolsInfo = this.$androidToolsInfo.getToolsInfo({
+            projectDir: this.$projectData.projectDir,
+        });
         const localArgs = [
             "-p",
             pluginBuildSettings.pluginDir,
             "assembleRelease",
             `-PtempBuild=true`,
+            `-PcompileSdk=${toolsInfo.compileSdkVersion}`,
+            `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`,
+            `-PprojectRoot=${this.$projectData.projectDir}`,
+            `-DprojectRoot=${this.$projectData.projectDir}`,
             `-PappPath=${this.$projectData.getAppDirectoryPath()}`,
+            `-PappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`,
+            `-DappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`,
             `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`,
         ];
         if (pluginBuildSettings.gradleArgs) {
-            localArgs.push(pluginBuildSettings.gradleArgs);
+            const additionalArgs = [];
+            pluginBuildSettings.gradleArgs.forEach((arg) => {
+                additionalArgs.push(...arg.split(" -P").map((a, i) => (i === 0 ? a : `-P${a}`)));
+            });
+            localArgs.push(...additionalArgs);
         }
         if (this.$logger.getLevel() === "INFO") {
-            localArgs.push("--quiet");
+            localArgs.push("--info");
         }
         const opts = {
             cwd: pluginBuildSettings.pluginDir,

package/lib/services/android-project-service.js

@@ -38,7 +38,7 @@ function topologicalSortNativeDependencies(dependencies, start = [], depth = 0,
     return sortedDeps;
 }
 class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase {
-    constructor($androidToolsInfo, $errors, $fs, $logger, $projectDataService, $options, $injector, $devicePlatformsConstants, $androidPluginBuildService, $platformEnvironmentRequirements, $androidResourcesMigrationService, $filesHashService, $gradleCommandService, $gradleBuildService, $analyticsService) {
+    constructor($androidToolsInfo, $errors, $fs, $logger, $projectDataService, $options, $injector, $devicePlatformsConstants, $androidPluginBuildService, $platformEnvironmentRequirements, $androidResourcesMigrationService, $liveSyncProcessDataService, $devicesService, $filesHashService, $gradleCommandService, $gradleBuildService, $analyticsService) {
         super($fs, $projectDataService);
         this.$androidToolsInfo = $androidToolsInfo;
         this.$errors = $errors;
@@ -49,6 +49,8 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         this.$androidPluginBuildService = $androidPluginBuildService;
         this.$platformEnvironmentRequirements = $platformEnvironmentRequirements;
         this.$androidResourcesMigrationService = $androidResourcesMigrationService;
+        this.$liveSyncProcessDataService = $liveSyncProcessDataService;
+        this.$devicesService = $devicesService;
         this.$filesHashService = $filesHashService;
         this.$gradleCommandService = $gradleCommandService;
         this.$gradleBuildService = $gradleBuildService;
@@ -176,6 +178,11 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         const targetSdkVersion = androidToolsInfo && androidToolsInfo.targetSdkVersion;
         this.$logger.trace(`Using Android SDK '${targetSdkVersion}'.`);
         this.copy(this.getPlatformData(projectData).projectRoot, frameworkDir, "*", "-R");
+        if (this.$options.overrideRuntimeGradleFiles !== false) {
+            const gradleTemplatePath = path.resolve(path.join(__dirname, "../../vendor/gradle-app"));
+            const allGradleTemplateFiles = path.join(gradleTemplatePath, "*");
+            this.$fs.copyFile(allGradleTemplateFiles, path.join(this.getPlatformData(projectData).projectRoot));
+        }
         this.cleanResValues(targetSdkVersion, projectData);
     }
     getResDestinationDir(projectData) {
@@ -220,7 +227,14 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         shell.sed("-i", /__NAME__/, projectData.projectName, stringsFilePath);
         shell.sed("-i", /__TITLE_ACTIVITY__/, projectData.projectName, stringsFilePath);
         const gradleSettingsFilePath = path.join(this.getPlatformData(projectData).projectRoot, "settings.gradle");
+        const relativePath = path.relative(this.getPlatformData(projectData).projectRoot, projectData.projectDir);
+        shell.sed("-i", /def USER_PROJECT_ROOT = \"\$rootDir\/..\/..\/\"/, `def USER_PROJECT_ROOT = "$rootDir/${relativePath}"`, gradleSettingsFilePath);
         shell.sed("-i", /__PROJECT_NAME__/, this.getProjectNameFromId(projectData), gradleSettingsFilePath);
+        const gradleVersion = projectData.nsConfig.android.gradleVersion;
+        if (gradleVersion) {
+            const gradleWrapperFilePath = path.join(this.getPlatformData(projectData).projectRoot, "gradle", "wrapper", "gradle-wrapper.properties");
+            shell.sed("-i", /gradle-([0-9.]+)-bin.zip/, `gradle-${gradleVersion}-bin.zip`, gradleWrapperFilePath);
+        }
         try {
             const appGradleContent = this.$fs.readText(projectData.appGradlePath);
             if (appGradleContent.indexOf(constants.PACKAGE_PLACEHOLDER_NAME) !== -1) {
@@ -234,6 +248,11 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
     interpolateConfigurationFile(projectData) {
         const manifestPath = this.getPlatformData(projectData).configurationFilePath;
         shell.sed("-i", /__PACKAGE__/, projectData.projectIdentifiers.android, manifestPath);
+        const buildAppGradlePath = path.join(this.getPlatformData(projectData).projectRoot, "app", "build.gradle");
+        const buildGradlePath = path.join(this.getPlatformData(projectData).projectRoot, "build.gradle");
+        shell.sed("-i", /__PACKAGE__/, projectData.projectIdentifiers.android, buildAppGradlePath);
+        const relativePath = path.relative(this.getPlatformData(projectData).projectRoot, projectData.projectDir);
+        shell.sed("-i", /project.ext.USER_PROJECT_ROOT = \"\$rootDir\/..\/..\"/, `project.ext.USER_PROJECT_ROOT = "$rootDir/${relativePath}"`, buildGradlePath);
     }
     getProjectNameFromId(projectData) {
         let id;
@@ -302,7 +321,18 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         this.$fs.ensureDirectoryExists(platformsAppResourcesPath);
         const appResourcesDirStructureHasMigrated = this.$androidResourcesMigrationService.hasMigrated(projectAppResourcesPath);
         if (appResourcesDirStructureHasMigrated) {
-            this.$fs.copyFile(path.join(projectAppResourcesPath, platformData.normalizedPlatformName, constants.SRC_DIR, "*"), platformsAppResourcesPath);
+            const resourcesPath = path.join(projectAppResourcesPath, platformData.normalizedPlatformName);
+            this.$fs.copyFile(path.join(resourcesPath, constants.SRC_DIR, "*"), platformsAppResourcesPath);
+            const destinationFolder = this.getPlatformData(projectData).projectRoot;
+            const contents = this.$fs.readDirectory(resourcesPath);
+            _.each(contents, (fileName) => {
+                const filePath = path.join(resourcesPath, fileName);
+                const fsStat = this.$fs.getFsStats(filePath);
+                if (fsStat.isDirectory() && fileName !== constants.SRC_DIR) {
+                    console.log("copying folder", filePath);
+                    this.$fs.copyFile(filePath, destinationFolder);
+                }
+            });
         }
         else {
             this.$fs.copyFile(path.join(projectAppResourcesPath, platformData.normalizedPlatformName, "*"), platformsAppResourcesPath);
@@ -317,14 +347,17 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
     async preparePluginNativeCode(pluginData, projectData) {
         const pluginPlatformsFolderPath = this.getPluginPlatformsFolderPath(pluginData, AndroidProjectService.ANDROID_PLATFORM_NAME);
         if (this.$fs.exists(pluginPlatformsFolderPath)) {
+            const gradleArgs = (projectData.nsConfig.android.gradleArgs || []).concat(this.$options.gradleArgs || []);
+            const pluginOptions = (projectData.nsConfig.android.plugins || {})[pluginData.name] || {};
             const options = {
                 gradlePath: this.$options.gradlePath,
-                gradleArgs: this.$options.gradleArgs,
+                gradleArgs,
                 projectDir: projectData.projectDir,
                 pluginName: pluginData.name,
                 platformsAndroidDirPath: pluginPlatformsFolderPath,
                 aarOutputDir: pluginPlatformsFolderPath,
                 tempPluginDirPath: path.join(projectData.platformsDir, "tempPlugin"),
+                ...pluginOptions
             };
             if (await this.$androidPluginBuildService.buildAar(options)) {
                 this.$logger.info(`Built aar for ${options.pluginName}`);
@@ -404,7 +437,33 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         const deviceRootPath = `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${projectData.projectIdentifiers.android}`;
         await adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
     }
-    async checkForChanges() {
+    async checkForChanges(changesInfo, prepareData, projectData) {
+        const deviceDescriptors = this.$liveSyncProcessDataService.getDeviceDescriptors(projectData.projectDir);
+        const platformData = this.getPlatformData(projectData);
+        deviceDescriptors.forEach((deviceDescriptor) => {
+            const buildData = deviceDescriptor.buildData;
+            if (buildData.buildFilterDevicesArch) {
+                const outputPath = platformData.getBuildOutputPath(deviceDescriptor.buildData);
+                const apkOutputPath = path.join(outputPath, prepareData.release ? "release" : "debug");
+                if (!this.$fs.exists(apkOutputPath)) {
+                    return;
+                }
+                const directoryContent = this.$fs.readDirectory(apkOutputPath);
+                if (!directoryContent.find(f => f.indexOf("universal") !== -1)) {
+                    const device = this.$devicesService
+                        .getDevicesForPlatform(deviceDescriptor.buildData.platform)
+                        .filter((d) => d.deviceInfo.identifier === deviceDescriptor.identifier)[0];
+                    const abis = device.deviceInfo.abis.filter((a) => !!a && a.length)[0];
+                    const regexp = new RegExp(`${abis}.*\.apk`);
+                    const files = _.filter(directoryContent, (entry) => {
+                        return regexp.test(entry);
+                    });
+                    if (files.length === 0) {
+                        changesInfo.nativeChanged = true;
+                    }
+                }
+            }
+        });
     }
     getDeploymentTarget(projectData) {
         return;

package/lib/services/build-artifacts-service.js

@@ -39,23 +39,38 @@ class BuildArtifactsService {
         }
         return [];
     }
-    copyLatestAppPackage(targetPath, platformData, buildOutputOptions) {
+    copyAppPackages(targetPath, platformData, buildOutputOptions) {
         targetPath = path.resolve(targetPath);
         const outputPath = buildOutputOptions.outputPath ||
             platformData.getBuildOutputPath(buildOutputOptions);
-        const applicationPackage = this.getLatestApplicationPackage(outputPath, platformData.getValidBuildOutputData(buildOutputOptions));
-        const packageFile = applicationPackage.packageName;
+        const applicationPackages = this.getAllAppPackages(outputPath, platformData.getValidBuildOutputData(buildOutputOptions));
         this.$fs.ensureDirectoryExists(path.dirname(targetPath));
+        let filterRegex;
+        let targetIsDirectory = false;
         if (this.$fs.exists(targetPath) &&
             this.$fs.getFsStats(targetPath).isDirectory()) {
-            const sourceFileName = path.basename(packageFile);
-            this.$logger.trace(`Specified target path: '${targetPath}' is directory. Same filename will be used: '${sourceFileName}'.`);
-            targetPath = path.join(targetPath, sourceFileName);
+            targetIsDirectory = true;
+        }
+        else if (targetPath.match(/\.(ipa|aab|apk)/)) {
+            if (applicationPackages.length > 1) {
+                filterRegex = new RegExp("universal");
+                this.$logger.trace(`Multiple packages were built but only the universal one will be copied if existing'.`);
+            }
         }
-        this.$fs.copyFile(packageFile, targetPath);
-        this.$logger.info(`Copied file '${packageFile}' to '${targetPath}'.`);
+        else {
+            targetIsDirectory = true;
+        }
+        applicationPackages.forEach((pack) => {
+            const targetFilePath = targetIsDirectory
+                ? path.join(targetPath, path.basename(pack.packageName))
+                : targetPath;
+            if (!filterRegex || filterRegex.test(pack.packageName)) {
+                this.$fs.copyFile(pack.packageName, targetFilePath);
+                this.$logger.info(`Copied file '${pack.packageName}' to '${targetFilePath}'.`);
+            }
+        });
     }
-    getLatestApplicationPackage(buildOutputPath, validBuildOutputData) {
+    getLatestApplicationPackage(buildOutputPath, validBuildOutputData, abis) {
         let packages = this.getAllAppPackages(buildOutputPath, validBuildOutputData);
         const packageExtName = path.extname(validBuildOutputData.packageNames[0]);
         if (packages.length === 0) {