nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

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

@@ -18,7 +18,6 @@ class GradleBuildArgsService {
         if (await this.$analyticsService.isEnabled(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) {
             args.push("-PgatherAnalyticsData=true");
         }
-        // allow modifying gradle args from a `before-build-task-args` hook
         await this.$hooksService.executeBeforeHooks("build-task-args", {
             hookArgs: { args },
         });
@@ -31,7 +30,6 @@ class GradleBuildArgsService {
     }
     getBaseTaskArgs(buildData) {
         const args = this.getBuildLoggingArgs();
-        // ensure we initialize project data
         this.$projectData.initializeProjectData(buildData.projectDir);
         args.push(`-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
         if (buildData.gradleArgs) {
@@ -63,4 +61,3 @@ class GradleBuildArgsService {
 }
 exports.GradleBuildArgsService = GradleBuildArgsService;
 yok_1.injector.register("gradleBuildArgsService", GradleBuildArgsService);
-//# sourceMappingURL=gradle-build-args-service.js.map

package/lib/services/android/gradle-build-service.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "events";
+import { IGradleBuildService, IGradleBuildArgsService, IGradleCommandService } from "../../definitions/gradle";
+import { IAndroidBuildData } from "../../definitions/build";
+import { IChildProcess } from "../../common/declarations";
+export declare class GradleBuildService extends EventEmitter implements IGradleBuildService {
+    private $childProcess;
+    private $gradleBuildArgsService;
+    private $gradleCommandService;
+    constructor($childProcess: IChildProcess, $gradleBuildArgsService: IGradleBuildArgsService, $gradleCommandService: IGradleCommandService);
+    buildProject(projectRoot: string, buildData: IAndroidBuildData): Promise<void>;
+    cleanProject(projectRoot: string, buildData: IAndroidBuildData): Promise<void>;
+}

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

@@ -39,4 +39,3 @@ class GradleBuildService extends events_1.EventEmitter {
 }
 exports.GradleBuildService = GradleBuildService;
 yok_1.injector.register("gradleBuildService", GradleBuildService);
-//# sourceMappingURL=gradle-build-service.js.map

package/lib/services/android/gradle-command-service.d.ts

@@ -0,0 +1,11 @@
+import { IChildProcess, IErrors, IHostInfo, ISpawnResult } from "../../common/declarations";
+import { IGradleCommandService, IGradleCommandOptions } from "../../definitions/gradle";
+export declare class GradleCommandService implements IGradleCommandService {
+    private $childProcess;
+    private $errors;
+    private $hostInfo;
+    private $logger;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $hostInfo: IHostInfo, $logger: ILogger);
+    executeCommand(gradleArgs: string[], options: IGradleCommandOptions): Promise<ISpawnResult>;
+    private executeCommandSafe;
+}

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

@@ -38,4 +38,3 @@ class GradleCommandService {
 }
 exports.GradleCommandService = GradleCommandService;
 yok_1.injector.register("gradleCommandService", GradleCommandService);
-//# sourceMappingURL=gradle-command-service.js.map

package/lib/services/android-device-debug-service.d.ts

@@ -0,0 +1,30 @@
+import { DebugServiceBase } from "./debug-service-base";
+import { IDeviceDebugService, IDebugData, IDebugOptions, IDebugResultInfo } from "../definitions/debug";
+import { IStaticConfig } from "../declarations";
+import { IErrors, INet } from "../common/declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+export declare class AndroidDeviceDebugService extends DebugServiceBase implements IDeviceDebugService {
+    protected device: Mobile.IAndroidDevice;
+    protected $devicesService: Mobile.IDevicesService;
+    protected $cleanupService: ICleanupService;
+    private $errors;
+    private $logger;
+    private $androidProcessService;
+    private $staticConfig;
+    private $net;
+    private $deviceLogProvider;
+    private _packageName;
+    private deviceIdentifier;
+    get platform(): string;
+    constructor(device: Mobile.IAndroidDevice, $devicesService: Mobile.IDevicesService, $cleanupService: ICleanupService, $errors: IErrors, $logger: ILogger, $androidProcessService: Mobile.IAndroidProcessService, $staticConfig: IStaticConfig, $net: INet, $deviceLogProvider: Mobile.IDeviceLogProvider);
+    debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<IDebugResultInfo>;
+    debugStop(): Promise<void>;
+    private removePortForwarding;
+    private getForwardedDebugPort;
+    private unixSocketForward;
+    private debugCore;
+    private printDebugPort;
+    private validateRunningApp;
+    private waitForDebugServer;
+    private isAppRunning;
+}

package/lib/services/android-device-debug-service.js

@@ -33,7 +33,6 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
     async debug(debugData, debugOptions) {
         this._packageName = debugData.applicationIdentifier;
         const result = await this.debugCore(debugData.applicationIdentifier, debugOptions);
-        // TODO: extract this logic outside the debug service
         if (debugOptions.start && !debugOptions.justlaunch) {
             const pid = await this.$androidProcessService.getAppProcessId(this.deviceIdentifier, debugData.applicationIdentifier);
             if (pid) {
@@ -56,7 +55,6 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
             `tcp:${port}`,
         ]);
     }
-    // TODO: Remove this method and reuse logic from androidProcessService
     async getForwardedDebugPort(deviceId, packageName) {
         let port = -1;
         const forwardsResult = await this.device.adb.executeCommand([
@@ -64,7 +62,6 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
             "--list",
         ]);
         const unixSocketName = `${packageName}-inspectorServer`;
-        //matches 123a188909e6czzc tcp:40001 localabstract:org.nativescript.testUnixSockets-debug
         const regexp = new RegExp(`(?:${deviceId} tcp:)([\\d]+)(?= localabstract:${unixSocketName})`, "g");
         const match = regexp.exec(forwardsResult);
         if (match) {
@@ -80,7 +77,6 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
         });
         return port;
     }
-    // TODO: Remove this method and reuse logic from androidProcessService
     async unixSocketForward(local, remote) {
         await this.device.adb.executeCommand([
             "forward",
@@ -106,7 +102,6 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
     async printDebugPort(deviceId, port) {
         this.$logger.info("device: " + deviceId + " debug port: " + port + "\n");
     }
-    // TODO: extract this logic outside the debug service
     async validateRunningApp(deviceId, packageName) {
         if (!(await this.isAppRunning(packageName, deviceId))) {
             this.$errors.fail(`The application ${packageName} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
@@ -149,4 +144,3 @@ __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceDebugService.prototype, "debugCore", null);
 yok_1.injector.register("androidDeviceDebugService", AndroidDeviceDebugService, false);
-//# sourceMappingURL=android-device-debug-service.js.map

package/lib/services/android-plugin-build-service.d.ts

@@ -0,0 +1,55 @@
+import { INodePackageManager, IWatchIgnoreListService, IOptions } from "../declarations";
+import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IAndroidPluginBuildService, IPluginBuildOptions } from "../definitions/android-plugin-migrator";
+import { IFileSystem, IChildProcess, IHostInfo, IErrors, IHooksService } from "../common/declarations";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class AndroidPluginBuildService implements IAndroidPluginBuildService {
+    private $fs;
+    private $childProcess;
+    private $hostInfo;
+    private $options;
+    private $logger;
+    private $packageManager;
+    private $projectData;
+    private $projectDataService;
+    private $devicePlatformsConstants;
+    private $errors;
+    private $filesHashService;
+    $hooksService: IHooksService;
+    private $injector;
+    private $watchIgnoreListService;
+    private get $platformsDataService();
+    constructor($fs: IFileSystem, $childProcess: IChildProcess, $hostInfo: IHostInfo, $options: IOptions, $logger: ILogger, $packageManager: INodePackageManager, $projectData: IProjectData, $projectDataService: IProjectDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $filesHashService: IFilesHashService, $hooksService: IHooksService, $injector: IInjector, $watchIgnoreListService: IWatchIgnoreListService);
+    private static MANIFEST_ROOT;
+    private getAndroidSourceDirectories;
+    private getManifest;
+    private updateManifestContent;
+    private createManifestContent;
+    private getXml;
+    private getIncludeGradleCompileDependenciesScope;
+    private getScope;
+    buildAar(options: IPluginBuildOptions): Promise<boolean>;
+    private cleanPluginDir;
+    private getSourceFilesHashes;
+    private writePluginHashInfo;
+    private shouldBuildAar;
+    private getPathToPluginBuildDataFile;
+    private updateManifest;
+    private copySourceSetDirectories;
+    private setupGradle;
+    private getRuntimeGradleVersions;
+    private getLatestRuntimeVersion;
+    private getLocalGradleVersions;
+    private getGradleVersions;
+    private getGradleVersionsCore;
+    private replaceGradleVersion;
+    private replaceGradleAndroidPluginVersion;
+    private replaceFileContent;
+    private addCompileDependencies;
+    private copyAar;
+    migrateIncludeGradle(options: IPluginBuildOptions): boolean;
+    private buildPlugin;
+    private validateOptions;
+    private validatePlatformsAndroidDirPathOption;
+}

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

@@ -54,15 +54,12 @@ class AndroidPluginBuildService {
     async updateManifestContent(oldManifestContent, defaultPackageName) {
         let xml = await this.getXml(oldManifestContent);
         let packageName = defaultPackageName;
-        // if the manifest file is full-featured and declares settings inside the manifest scope
         if (xml["manifest"]) {
             if (xml["manifest"]["$"]["package"]) {
                 packageName = xml["manifest"]["$"]["package"];
             }
-            // set the xml as the value to iterate over its properties
             xml = xml["manifest"];
         }
-        // if the manifest file doesn't have a <manifest> scope, only the first setting will be picked up
         const newManifest = { manifest: {} };
         for (const prop in xml) {
             newManifest.manifest[prop] = xml[prop];
@@ -135,14 +132,6 @@ class AndroidPluginBuildService {
         }
         return result;
     }
-    /**
-     * Returns whether the build has completed or not
-     * @param {Object} options
-     * @param {string} options.pluginName - The name of the plugin. E.g. 'nativescript-barcodescanner'
-     * @param {string} options.platformsAndroidDirPath - The path to the 'plugin/src/platforms/android' directory.
-     * @param {string} options.aarOutputDir - The path where the aar should be copied after a successful build.
-     * @param {string} options.tempPluginDirPath - The path where the android plugin will be built.
-     */
     async buildAar(options) {
         this.validateOptions(options);
         const manifestFilePath = this.getManifest(options.platformsAndroidDirPath);
@@ -178,7 +167,6 @@ class AndroidPluginBuildService {
         return shouldBuildAar;
     }
     cleanPluginDir(pluginTempDir) {
-        // In case plugin was already built in the current process, we need to clean the old sources as they may break the new build.
         this.$fs.deleteDirectory(pluginTempDir);
         this.$fs.ensureDirectoryExists(pluginTempDir);
     }
@@ -252,7 +240,6 @@ class AndroidPluginBuildService {
         this.replaceGradleAndroidPluginVersion(buildGradlePath, runtimeGradleVersions.gradleAndroidPluginVersion);
         this.replaceFileContent(buildGradlePath, "{{pluginName}}", pluginName);
         this.replaceFileContent(settingsGradlePath, "{{pluginName}}", pluginName);
-        // gets the package from the AndroidManifest to use as the namespace or fallback to the `org.nativescript.${shortPluginName}`
         const shortPluginName = (0, helpers_1.getShortPluginName)(pluginName);
         const manifestPath = path.join(pluginTempDir, "src", "main", "AndroidManifest.xml");
         const manifestContent = this.$fs.readText(manifestPath);
@@ -305,7 +292,6 @@ class AndroidPluginBuildService {
         var _a, _b;
         const packageName = ((_b = (_a = this.$projectData.nsConfig) === null || _a === void 0 ? void 0 : _a.android) === null || _b === void 0 ? void 0 : _b.runtimePackageName) ||
             constants_1.SCOPED_ANDROID_RUNTIME_NAME;
-        // try reading from installed runtime first before reading from the npm registry...
         const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(packageName, {
             paths: [this.$projectData.projectDir],
         });
@@ -341,23 +327,13 @@ class AndroidPluginBuildService {
         }
         const packageName = ((_b = (_a = this.$projectData.nsConfig) === null || _a === void 0 ? void 0 : _a.android) === null || _b === void 0 ? void 0 : _b.runtimePackageName) ||
             constants_1.SCOPED_ANDROID_RUNTIME_NAME;
-        // fallback to reading from npm...
         try {
             let output = await this.$packageManager.view(`${packageName}@${runtimeVersion}`, { version_info: true });
             output = (_c = output === null || output === void 0 ? void 0 : output["version_info"]) !== null && _c !== void 0 ? _c : output;
             if (!output) {
-                /**
-                 * fallback to the old 'gradle' key in package.json
-                 *
-                 * format:
-                 *
-                 * gradle: { version: '6.4', android: '3.6.4' }
-                 *
-                 */
                 output = await this.$packageManager.view(`${packageName}@${runtimeVersion}`, { gradle: true });
                 output = (_d = output === null || output === void 0 ? void 0 : output["gradle"]) !== null && _d !== void 0 ? _d : output;
                 const { version, android } = output;
-                // covert output to the new format...
                 output = {
                     gradle: version,
                     gradleAndroid: android,
@@ -429,10 +405,6 @@ class AndroidPluginBuildService {
             this.$errors.fail(`No built aar found at ${pathToBuiltAar}`);
         }
     }
-    /**
-     * @param {Object} options
-     * @param {string} options.platformsAndroidDirPath - The path to the 'plugin/src/platforms/android' directory.
-     */
     migrateIncludeGradle(options) {
         this.validatePlatformsAndroidDirPathOption(options);
         const includeGradleFilePath = path.join(options.platformsAndroidDirPath, constants_1.INCLUDE_GRADLE_NAME);
@@ -485,8 +457,8 @@ class AndroidPluginBuildService {
         };
         if (this.$options.hostProjectPath) {
             opts.env = {
-                USER_PROJECT_PLATFORMS_ANDROID: path.resolve((0, process_1.cwd)(), this.$options.hostProjectPath), // TODO: couldn't `hostProjectPath` have an absolute path already?
-                ...process.env, // TODO: any other way to pass automatically the current process.env?
+                USER_PROJECT_PLATFORMS_ANDROID: path.resolve((0, process_1.cwd)(), this.$options.hostProjectPath),
+                ...process.env,
             };
         }
         try {
@@ -533,4 +505,3 @@ __decorate([
     (0, helpers_1.hook)("buildAndroidPlugin")
 ], AndroidPluginBuildService.prototype, "buildPlugin", null);
 yok_1.injector.register("androidPluginBuildService", AndroidPluginBuildService);
-//# sourceMappingURL=android-plugin-build-service.js.map

package/lib/services/android-project-service.d.ts

@@ -0,0 +1,75 @@
+import * as semver from "semver";
+import * as projectServiceBaseLib from "./platform-project-service-base";
+import { IProjectData, IProjectDataService, IValidatePlatformOutput } from "../definitions/project";
+import { IPlatformData, IPlatformEnvironmentRequirements } from "../definitions/platform";
+import { IAndroidToolsInfo, IAndroidResourcesMigrationService, IOptions, IDependencyData } from "../declarations";
+import { IAndroidBuildData } from "../definitions/build";
+import { IPluginData } from "../definitions/plugins";
+import { IErrors, IFileSystem, IAnalyticsService, IRelease, ISpawnResult } from "../common/declarations";
+import { IAndroidPluginBuildService } from "../definitions/android-plugin-migrator";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IGradleCommandService, IGradleBuildService } from "../definitions/gradle";
+import { IInjector } from "../common/definitions/yok";
+import { INotConfiguredEnvOptions } from "../common/definitions/commands";
+export declare class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase {
+    private $androidToolsInfo;
+    private $errors;
+    private $logger;
+    private $options;
+    private $injector;
+    private $devicePlatformsConstants;
+    private $androidPluginBuildService;
+    private $platformEnvironmentRequirements;
+    private $androidResourcesMigrationService;
+    private $filesHashService;
+    private $gradleCommandService;
+    private $gradleBuildService;
+    private $analyticsService;
+    private static VALUES_DIRNAME;
+    private static VALUES_VERSION_DIRNAME_PREFIX;
+    private static ANDROID_PLATFORM_NAME;
+    private static MIN_RUNTIME_VERSION_WITH_GRADLE;
+    constructor($androidToolsInfo: IAndroidToolsInfo, $errors: IErrors, $fs: IFileSystem, $logger: ILogger, $projectDataService: IProjectDataService, $options: IOptions, $injector: IInjector, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $androidPluginBuildService: IAndroidPluginBuildService, $platformEnvironmentRequirements: IPlatformEnvironmentRequirements, $androidResourcesMigrationService: IAndroidResourcesMigrationService, $filesHashService: IFilesHashService, $gradleCommandService: IGradleCommandService, $gradleBuildService: IGradleBuildService, $analyticsService: IAnalyticsService);
+    private _platformData;
+    getPlatformData(projectData: IProjectData): IPlatformData;
+    getCurrentPlatformVersion(platformData: IPlatformData, projectData: IProjectData): string;
+    validateOptions(): Promise<boolean>;
+    getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string;
+    validate(projectData: IProjectData, options: IOptions, notConfiguredEnvOptions?: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput>;
+    createProject(frameworkDir: string, frameworkVersion: string, projectData: IProjectData): Promise<void>;
+    private getResDestinationDir;
+    private cleanResValues;
+    interpolateData(projectData: IProjectData): Promise<void>;
+    interpolateConfigurationFile(projectData: IProjectData): void;
+    private getProjectNameFromId;
+    afterCreateProject(projectRoot: string): void;
+    updatePlatform(currentVersion: string, newVersion: string, canUpdate: boolean, projectData: IProjectData, addPlatform?: Function, removePlatforms?: (platforms: string[]) => Promise<void>): Promise<boolean>;
+    buildProject(projectRoot: string, projectData: IProjectData, buildData: IAndroidBuildData): Promise<void>;
+    buildForDeploy(projectRoot: string, projectData: IProjectData, buildData?: IAndroidBuildData): Promise<void>;
+    isPlatformPrepared(projectRoot: string, projectData: IProjectData): boolean;
+    getFrameworkFilesExtensions(): string[];
+    prepareProject(): Promise<void>;
+    ensureConfigurationFileInAppResources(projectData: IProjectData): void;
+    prepareAppResources(projectData: IProjectData): void;
+    preparePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+    processConfigurationFilesFromAppResources(): Promise<void>;
+    removePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+    beforePrepareAllPlugins(projectData: IProjectData, dependencies?: IDependencyData[]): Promise<IDependencyData[]>;
+    handleNativeDependenciesChange(projectData: IProjectData, opts: IRelease): Promise<void>;
+    private filterUniqueDependencies;
+    private provideDependenciesJson;
+    private static isNativeAndroidDependency;
+    stopServices(projectRoot: string): Promise<ISpawnResult>;
+    cleanProject(projectRoot: string): Promise<void>;
+    cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void>;
+    checkForChanges(): Promise<void>;
+    getDeploymentTarget(projectData: IProjectData): semver.SemVer;
+    private copy;
+    private validatePackageName;
+    private validateProjectName;
+    private getLegacyAppResourcesDestinationDirPath;
+    private getUpdatedAppResourcesDestinationDirPath;
+    private cleanUpPreparedResources;
+    private trackKotlinUsage;
+    private tryGetAndroidBuildStatistics;
+}

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

@@ -18,40 +18,7 @@ const constants_1 = require("../common/constants");
 const helpers_1 = require("../common/helpers");
 const decorators_1 = require(".././common/decorators");
 const yok_1 = require("../common/yok");
-//
-// we sort the native dependencies topologically to make sure they are processed in the right order
-// native dependenciess need to be sorted so the deepst dependencies are built before it's parents
-//
-// for example, given this dep structure (assuming these are all native dependencies that need to be built)
-// (note: we list all dependencies at the root level, so the leaf nodes are essentially references to the root nodes)
-//
-//   |- dep1
-//   |- dep2
-//   |- |- dep3
-//   |- |- dep4
-//   |- |- |- dep5
-//   |- dep3
-//   |- dep4
-//   |- |- dep5
-//   |- dep5
-//
-// It is sorted:
-//
-//   |- dep1
-//   |- dep3
-//   |- dep5
-//   |- dep4        # depends on dep5, so dep5 must be built first, ie above ^
-//   |- |- dep5
-//   |- dep2        # depends on dep3, dep4 (and dep5 through dep4) so all of them must be built first before dep2 is built
-//   |- |- dep3
-//   |- |- dep4
-//   |- |- |- dep5
-//
-// for more details see: https://wikiless.org/wiki/Topological_sorting?lang=en
-//
-function topologicalSortNativeDependencies(dependencies, start = [], depth = 0, total = 0 // do not pass in, we calculate it in the initial run!
-) {
-    // we set the total on the initial call - and never increment it, as it's used for esacaping the recursion
+function topologicalSortNativeDependencies(dependencies, start = [], depth = 0, total = 0) {
     if (total === 0) {
         total = dependencies.length;
     }
@@ -65,8 +32,6 @@ function topologicalSortNativeDependencies(dependencies, start = [], depth = 0,
         return sortedDeps;
     }, start);
     const remainingDeps = dependencies.filter((nativeDep) => !sortedDeps.includes(nativeDep));
-    // recurse if we still have remaining deps
-    // the second condition here prevents infinite recursion
     if (remainingDeps.length && sortedDeps.length < total) {
         return topologicalSortNativeDependencies(remainingDeps, sortedDeps, depth + 1, total);
     }
@@ -120,7 +85,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 constants.APK_DIR,
             ];
             const packageName = this.getProjectNameFromId(projectData);
-            const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, "android" /* constants.PlatformTypes.android */);
+            const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, constants.PlatformTypes.android);
             this._platformData = {
                 frameworkPackageName: runtimePackage.name,
                 normalizedPlatformName: "Android",
@@ -161,7 +126,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 configurationFileName: constants.MANIFEST_FILE_NAME,
                 configurationFilePath: path.join(...configurationsDirectoryArr),
                 relativeToFrameworkConfigurationFilePath: path.join(constants.SRC_DIR, constants.MAIN_DIR, constants.MANIFEST_FILE_NAME),
-                fastLivesyncFileExtensions: [".jpg", ".gif", ".png", ".bmp", ".webp"], // http://developer.android.com/guide/appendix/media-formats.html
+                fastLivesyncFileExtensions: [".jpg", ".gif", ".png", ".bmp", ".webp"],
             };
         }
         return this._platformData;
@@ -214,7 +179,6 @@ 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");
-        // TODO: Check if we actually need this and if it should be targetSdk or compileSdk
         this.cleanResValues(targetSdkVersion, projectData);
     }
     getResDestinationDir(projectData) {
@@ -246,7 +210,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         _.map(directoriesToClean, (dir) => this.$fs.deleteDirectory(dir));
     }
     async interpolateData(projectData) {
-        // Interpolate the apilevel and package
         this.interpolateConfigurationFile(projectData);
         const appResourcesDirectoryPath = projectData.getAppResourcesDirectoryPath();
         let stringsFilePath;
@@ -262,10 +225,8 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         const gradleSettingsFilePath = path.join(this.getPlatformData(projectData).projectRoot, "settings.gradle");
         shell.sed("-i", /__PROJECT_NAME__/, this.getProjectNameFromId(projectData), gradleSettingsFilePath);
         try {
-            // will replace applicationId in app/App_Resources/Android/app.gradle if it has not been edited by the user
             const appGradleContent = this.$fs.readText(projectData.appGradlePath);
             if (appGradleContent.indexOf(constants.PACKAGE_PLACEHOLDER_NAME) !== -1) {
-                //TODO: For compatibility with old templates. Once all templates are updated should delete.
                 shell.sed("-i", new RegExp(constants.PACKAGE_PLACEHOLDER_NAME), projectData.projectIdentifiers.android, projectData.appGradlePath);
             }
         }
@@ -319,7 +280,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         return [".jar", ".dat"];
     }
     async prepareProject() {
-        // Intentionally left empty.
     }
     ensureConfigurationFileInAppResources(projectData) {
         const appResourcesDirectoryPath = projectData.appResourcesDirectoryPath;
@@ -336,7 +296,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
             this.$logger.warn("No manifest found in " + originalAndroidManifestFilePath);
             return;
         }
-        // Overwrite the AndroidManifest from runtime.
         if (!appResourcesDirStructureHasMigrated) {
             this.$fs.copyFile(originalAndroidManifestFilePath, this.getPlatformData(projectData).configurationFilePath);
         }
@@ -353,8 +312,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         }
         else {
             this.$fs.copyFile(path.join(projectAppResourcesPath, platformData.normalizedPlatformName, "*"), platformsAppResourcesPath);
-            // https://github.com/NativeScript/android-runtime/issues/899
-            // App_Resources/Android/libs is reserved to user's aars and jars, but they should not be copied as resources
             this.$fs.deleteDirectory(path.join(platformsAppResourcesPath, "libs"));
         }
         const androidToolsInfo = this.$androidToolsInfo.getToolsInfo({
@@ -364,7 +321,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         this.cleanResValues(compileSdkVersion, projectData);
     }
     async preparePluginNativeCode(pluginData, projectData) {
-        // build Android plugins which contain AndroidManifest.xml and/or resources
         const pluginPlatformsFolderPath = this.getPluginPlatformsFolderPath(pluginData, AndroidProjectService.ANDROID_PLATFORM_NAME);
         if (this.$fs.exists(pluginPlatformsFolderPath)) {
             const options = {
@@ -386,7 +342,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         return;
     }
     async removePluginNativeCode(pluginData, projectData) {
-        // not implemented
     }
     async beforePrepareAllPlugins(projectData, dependencies) {
         if (dependencies) {
@@ -400,7 +355,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
     filterUniqueDependencies(dependencies) {
         const depsDictionary = dependencies.reduce((dict, dep) => {
             const collision = dict[dep.name];
-            // in case there are multiple dependencies to the same module, the one declared in the package.json takes precedence
             if (!collision || collision.depth > dep.depth) {
                 dict[dep.name] = dep;
             }
@@ -419,7 +373,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 name,
                 directory: path.relative(platformDir, directory),
                 dependencies: dependencies.filter((dep) => {
-                    // filter out transient dependencies that don't have native dependencies
                     return (nativeDependencyData.findIndex((nativeDep) => nativeDep.name === dep) !== -1);
                 }),
             };
@@ -427,7 +380,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         nativeDependencies = topologicalSortNativeDependencies(nativeDependencies);
         const jsonContent = JSON.stringify(nativeDependencies, null, 4);
         this.$fs.writeFile(dependenciesJsonPath, jsonContent);
-        // we sort all the dependencies to respect the topological sorting of the native dependencies
         return dependencies.sort(function (a, b) {
             return (nativeDependencies.findIndex((n) => n.name === a.name) -
                 nativeDependencies.findIndex((n) => n.name === b.name));
@@ -459,7 +411,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         await adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
     }
     async checkForChanges() {
-        // Nothing android specific to check yet.
     }
     getDeploymentTarget(projectData) {
         return;
@@ -469,12 +420,9 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         shell.cp(cpArg, paths, projectRoot);
     }
     validatePackageName(packageName) {
-        //Make the package conform to Java package types
-        //Enforce underscore limitation
         if (!/^[a-zA-Z]+(\.[a-zA-Z0-9][a-zA-Z0-9_]*)+$/.test(packageName)) {
             this.$errors.fail(`Package name must look like: com.company.Name. Got: ${packageName}`);
         }
-        //Class is a reserved word
         if (/\b[Cc]lass\b/.test(packageName)) {
             this.$errors.fail("class is a reserved word");
         }
@@ -483,7 +431,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         if (projectName === "") {
             this.$errors.fail("Project name cannot be empty");
         }
-        //Classes in Java don't begin with numbers
         if (/^[0-9]/.test(projectName)) {
             this.$errors.fail("Project name must not begin with a number");
         }
@@ -504,19 +451,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         ];
         return path.join(this.getPlatformData(projectData).projectRoot, ...resourcePath);
     }
-    /**
-     * The purpose of this method is to delete the previously prepared user resources.
-     * The content of the `<platforms>/android/.../res` directory is based on user's resources and gradle project template from android-runtime.
-     * During preparation of the `<path to user's App_Resources>/Android` we want to clean all the users files from previous preparation,
-     * but keep the ones that were introduced during `platform add` of the android-runtime.
-     * Currently the Gradle project template contains resources only in values and values-v21 directories.
-     * So the current logic of the method is cleaning al resources from `<platforms>/android/.../res` that are not in `values.*` directories
-     * and that exist in the `<path to user's App_Resources>/Android/.../res` directory
-     * This means that if user has a resource file in values-v29 for example, builds the project and then deletes this resource,
-     * it will be kept in platforms directory. Reference issue: `https://github.com/NativeScript/nativescript-cli/issues/5083`
-     * Same is valid for files in `drawable-<resolution>` directories - in case in user's resources there's drawable-hdpi directory,
-     * which is deleted after the first build of app, it will remain in platforms directory.
-     */
     cleanUpPreparedResources(projectData) {
         let resourcesDirPath = path.join(projectData.appResourcesDirectoryPath, this.getPlatformData(projectData).normalizedPlatformName);
         if (this.$androidResourcesMigrationService.hasMigrated(projectData.appResourcesDirectoryPath)) {
@@ -541,7 +475,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 const hasUseKotlinPropertyInAppData = `hasUseKotlinPropertyInApp${analyticsDelimiter}${buildStatistics.kotlinUsage.hasUseKotlinPropertyInApp}`;
                 const hasKotlinRuntimeClassesData = `hasKotlinRuntimeClasses${analyticsDelimiter}${buildStatistics.kotlinUsage.hasKotlinRuntimeClasses}`;
                 await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                    action: "Using Kotlin" /* constants.TrackActionNames.UsingKotlin */,
+                    action: constants.TrackActionNames.UsingKotlin,
                     additionalData: `${hasUseKotlinPropertyInAppData}${analyticsDelimiter}${hasKotlinRuntimeClassesData}`,
                 });
             }
@@ -574,4 +508,3 @@ __decorate([
     (0, helpers_1.hook)("buildAndroid")
 ], AndroidProjectService.prototype, "buildProject", null);
 yok_1.injector.register("androidProjectService", AndroidProjectService);
-//# sourceMappingURL=android-project-service.js.map

package/lib/services/android-resources-migration-service.d.ts

@@ -0,0 +1,17 @@
+import { IAndroidResourcesMigrationService } from "../declarations";
+import { IFileSystem, IErrors } from "../common/declarations";
+export declare class AndroidResourcesMigrationService implements IAndroidResourcesMigrationService {
+    private $fs;
+    private $errors;
+    private $logger;
+    private $devicePlatformsConstants;
+    private static ANDROID_DIR;
+    private static ANDROID_DIR_TEMP;
+    private static ANDROID_DIR_OLD;
+    constructor($fs: IFileSystem, $errors: IErrors, $logger: ILogger, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    canMigrate(platformString: string): boolean;
+    hasMigrated(appResourcesDir: string): boolean;
+    migrate(appResourcesDir: string, backupLocation?: string): Promise<void>;
+    private tryMigrate;
+    private recover;
+}

package/lib/services/android-resources-migration-service.js

@@ -46,7 +46,6 @@ class AndroidResourcesMigrationService {
         const appResourcesMainSourceSetResourcesDestination = path.join(appMainSourceSet, constants.RESOURCES_DIR);
         this.$fs.ensureDirectoryExists(appResourcesDestination);
         this.$fs.ensureDirectoryExists(appMainSourceSet);
-        // create /java, /res and /assets in the App_Resources/Android/src/main directory
         this.$fs.ensureDirectoryExists(appResourcesMainSourceSetResourcesDestination);
         this.$fs.ensureDirectoryExists(path.join(appMainSourceSet, "java"));
         this.$fs.ensureDirectoryExists(path.join(appMainSourceSet, constants.ASSETS_DIR));
@@ -60,25 +59,20 @@ class AndroidResourcesMigrationService {
         const resourceFiles = getFiles(appResourcesFiles);
         resourceDirectories.forEach((dir) => {
             if (path.basename(dir) !== "libs") {
-                // don't copy /App_Resources/Android/libs into the src/main/res/libs directory
                 this.$fs.copyFile(dir, appResourcesMainSourceSetResourcesDestination);
             }
             else {
-                // copy App_Resources/Android/libs to App_ResourcesNew/Android/libs
                 this.$fs.copyFile(dir, path.join(appResourcesDestination));
             }
         });
         resourceFiles.forEach((file) => {
             const fileName = path.basename(file);
             if (fileName !== constants.MANIFEST_FILE_NAME) {
-                // don't copy AndroidManifest into /App_Resources/Android as it needs to be inside src/main/
                 this.$fs.copyFile(file, path.join(appResourcesDestination, fileName));
             }
         });
         this.$fs.copyFile(path.join(originalAppResources, constants.MANIFEST_FILE_NAME), path.join(appMainSourceSet, constants.MANIFEST_FILE_NAME));
-        // rename the legacy app_resources to ANDROID_DIR_OLD
         this.$fs.rename(originalAppResources, appResourcesBackup);
-        // move the new, updated app_resources to App_Resources/Android, as  the de facto resources
         this.$fs.rename(appResourcesDestination, originalAppResources);
     }
     recover(originalAppResources, appResourcesDestination, appResourcesBackup) {
@@ -95,4 +89,3 @@ AndroidResourcesMigrationService.ANDROID_DIR = "Android";
 AndroidResourcesMigrationService.ANDROID_DIR_TEMP = "Android-Updated";
 AndroidResourcesMigrationService.ANDROID_DIR_OLD = "Android-Pre-v4";
 yok_1.injector.register("androidResourcesMigrationService", AndroidResourcesMigrationService);
-//# sourceMappingURL=android-resources-migration-service.js.map