feat(resources-update-command): introduce resources-update command

Introduce the 'tns resources-update android' command. By design, upon execution it should migrate the directory structure of App_Resources/Android to the new v4 structure - the one that supports inclusion of java source files, arbitrary assets, and any resource files in the App_Resources/Android/src/main directory structure. Additional, user-defined flavors can also be created taking advantage of the new dir structure.

docs(resources-update-command): add documentation for the new resources-update command

fix(resources-update-command): make prepare and run backward-compatible

fix(resource-update-command-tests): inject the new service in tests

Author: petekanev

docs/man_pages/index.md

@@ -32,6 +32,7 @@ Command | Description
 [platform list](project/configuration/platform.html) | Lists all platforms that the project currently targets.
 [platform&nbsp;remove&nbsp;`<Platform>`](project/configuration/platform-remove.html) | Removes the selected platform from the platforms that the project currently targets. This operation deletes all platform-specific files and subdirectories from your project.
 [platform update `<Platform>`](project/configuration/platform-update.html) | Updates the NativeScript runtime for the specified platform.
+[resources-update](project/configuration/resources-update.html) | Updates the App_Resources/<platform>'s internal folder structure to conform to that of an Android project.
 [prepare `<Platform>`](project/configuration/prepare.html) | Copies relevant content from the app directory to the subdirectory for the selected target platform to let you build the project.
 [build `<Platform>`](project/testing/build.html) | Builds the project for the selected target platform and produces an application package or an emulator package.
 [deploy `<Platform>`](project/testing/deploy.html) | Deploys the project to a connected physical or virtual device.

docs/man_pages/project/configuration/resources-update.md

@@ -0,0 +1,31 @@
+<% if (isJekyll) { %>---
+title: tns resources-update
+position: 9
+---<% } %>
+#tns resources-update
+==========
+
+Usage | Synopsis
+------|-------
+`$ tns resources-update` | Defaults to executing `$ tns resources-update android`. Updates the App_Resources/Android's folder structure.
+`$ tns resources-update android` | Updates the App_Resources/Android's folder structure.
+
+Updates the App_Resources/<platform>'s internal folder structure to conform to that of an Android project. Android resource files and directories will be located at the following paths:
+- `drawable-*`, `values`, `raw`, etc. can be found at  `App_Resources/Android/src/main/res` 
+- `AndroidManifest.xml` can be found at `App_Resources/Android/src/main/AndroidManifest.xml`
+- Java source files can be dropped in at `App_Resources/Android/src/main/java` after creating the proper package subdirectory structure
+- Additional arbitrary assets can be dropped in at `App_Resources/Android/src/main/assets`
+
+### Command Limitations
+
+* The command works only for the directory structure under `App_Resources/Android`. Running `$ tns resources-update ios` will have no effect.
+
+### Related Commands
+
+Command | Description
+----------|----------
+[install](install.html) | Installs all platforms and dependencies described in the `package.json` file in the current directory.
+[platform add](platform-add.html) | Configures the current project to target the selected platform.
+[platform remove](platform-remove.html) | Removes the selected platform from the platforms that the project currently targets.
+[platform](platform.html) | Lists all platforms that the project currently targets.
+[prepare](prepare.html) | Copies common and relevant platform-specific content from the app directory to the subdirectory for the selected target platform in the platforms directory.

docs/man_pages/project/configuration/update.md

@@ -21,4 +21,5 @@ Command | Description
 [platform remove](platform-remove.html) | Removes the selected platform from the platforms that the project currently targets.
 [platform](platform.html) | Lists all platforms that the project currently targets.
 [prepare](prepare.html) | Copies common and relevant platform-specific content from the app directory to the subdirectory for the selected target platform in the platforms directory.
-[platform update](platform-update.html) | Updates the NativeScript runtime for the specified platform.
+[platform update](platform-update.html) | Updates the NativeScript runtime for the specified platform.
+[resources-update android](resources-update.html) | Updates the App_Resources/Android directory to the new v4.0 directory structure

ios/testApp/testApp.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>aps-environment</key>
+    <string>production</string>
+    <key>nameKey</key>
+    <string>appResources</string>
+  </dict>
+</plist>

lib/bootstrap.ts

@@ -102,6 +102,9 @@ $injector.requireCommand("init", "./commands/init");
 $injector.require("infoService", "./services/info-service");
 $injector.requireCommand("info", "./commands/info");
 
+$injector.require("androidResourcesMigrationService", "./services/android-resources-migration-service");
+$injector.requireCommand("resources-update", "./commands/resources-update");
+
 $injector.require("androidToolsInfo", "./android-tools-info");
 $injector.require("devicePathProvider", "./device-path-provider");
 

lib/commands/resources-update.ts

@@ -0,0 +1,34 @@
+export class ResourcesUpdateCommand implements ICommand {
+	public allowedParameters: ICommandParameter[] = [];
+
+	constructor(private $projectData: IProjectData,
+		private $errors: IErrors,
+		private $androidResourcesMigrationService: IAndroidResourcesMigrationService) {
+		this.$projectData.initializeProjectData();
+	}
+
+	public async execute(args: string[]): Promise<void> {
+		await this.$androidResourcesMigrationService.migrate(this.$projectData.getAppResourcesDirectoryPath());
+	}
+
+	public async canExecute(args: string[]): Promise<boolean> {
+		if (!args || args.length === 0) {
+			// Command defaults to migrating the Android App_Resources, unless explicitly specified
+			args = ["android"];
+		}
+
+		for (const platform of args) {
+			if (!this.$androidResourcesMigrationService.canMigrate(platform)) {
+				this.$errors.failWithoutHelp(`The ${platform} does not need to have its resources updated.`);
+			}
+
+			if (this.$androidResourcesMigrationService.hasMigrated(this.$projectData.getAppResourcesDirectoryPath())) {
+				this.$errors.failWithoutHelp("The App_Resources have already been updated for the Android platform.");
+			}
+		}
+
+		return true;
+	}
+}
+
+$injector.registerCommand("resources-update", ResourcesUpdateCommand);

lib/declarations.d.ts

@@ -497,6 +497,12 @@ interface IInfoService {
 	printComponentsInfo(): Promise<void>;
 }
 
+interface IAndroidResourcesMigrationService {
+	canMigrate(platformString: string): boolean;
+	hasMigrated(appResourcesDir: string): boolean;
+	migrate(appResourcesDir: string): Promise<void>;
+}
+
 /**
  * Describes properties needed for uploading a package to iTunes Connect
  */

lib/services/android-project-service.ts

@@ -5,7 +5,6 @@ import * as semver from "semver";
 import * as projectServiceBaseLib from "./platform-project-service-base";
 import { DeviceAndroidDebugBridge } from "../common/mobile/android/device-android-debug-bridge";
 import { attachAwaitDetach } from "../common/helpers";
-import { EOL } from "os";
 import { Configurations } from "../common/constants";
 import { SpawnOptions } from "child_process";
 
@@ -36,7 +35,8 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		private $injector: IInjector,
 		private $pluginVariablesService: IPluginVariablesService,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
-		private $npm: INodePackageManager) {
+		private $npm: INodePackageManager,
+		private $androidResourcesMigrationService: IAndroidResourcesMigrationService) {
 		super($fs, $projectDataService);
 		this._androidProjectPropertiesManagers = Object.create(null);
 		this.isAndroidStudioTemplate = false;
@@ -133,18 +133,14 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		return Promise.resolve(true);
 	}
 
-	public getAppResourcesDestinationDirectoryPath(projectData: IProjectData, frameworkVersion?: string): string {
-		if (this.canUseGradle(projectData, frameworkVersion)) {
-			const resourcePath: string[] = [constants.SRC_DIR, constants.MAIN_DIR, constants.RESOURCES_DIR];
-			if (this.isAndroidStudioTemplate) {
-				resourcePath.unshift(constants.APP_FOLDER_NAME);
-			}
-
-			return path.join(this.getPlatformData(projectData).projectRoot, ...resourcePath);
+	public getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string {
+		const appResourcesDirStructureHasMigrated = this.$androidResourcesMigrationService.hasMigrated(projectData.getAppResourcesDirectoryPath());
 
+		if (appResourcesDirStructureHasMigrated) {
+			return this.getUpdatedAppResourcesDestinationDirPath(projectData);
+		} else {
+			return this.getLegacyAppResourcesDestinationDirPath(projectData);
 		}
-
-		return path.join(this.getPlatformData(projectData).projectRoot, constants.RESOURCES_DIR);
 	}
 
 	public async validate(projectData: IProjectData): Promise<void> {
@@ -199,7 +195,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			this.copy(this.getPlatformData(projectData).projectRoot, frameworkDir, "gradlew gradlew.bat", "-f");
 		}
 
-		this.cleanResValues(targetSdkVersion, projectData, frameworkVersion);
+		this.cleanResValues(targetSdkVersion, projectData);
 
 		const npmConfig: INodePackageManagerInstallOptions = {
 			save: true,
@@ -235,8 +231,8 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		}
 	}
 
-	private cleanResValues(targetSdkVersion: number, projectData: IProjectData, frameworkVersion: string): void {
-		const resDestinationDir = this.getAppResourcesDestinationDirectoryPath(projectData, frameworkVersion);
+	private cleanResValues(targetSdkVersion: number, projectData: IProjectData): void {
+		const resDestinationDir = this.getAppResourcesDestinationDirectoryPath(projectData);
 		const directoriesInResFolder = this.$fs.readDirectory(resDestinationDir);
 		const directoriesToClean = directoriesInResFolder
 			.map(dir => {
@@ -260,8 +256,16 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	public async interpolateData(projectData: IProjectData, platformSpecificData: IPlatformSpecificData): Promise<void> {
 		// Interpolate the apilevel and package
 		this.interpolateConfigurationFile(projectData, platformSpecificData);
+		const appResourcesDirectoryPath = projectData.getAppResourcesDirectoryPath();
+
+		let stringsFilePath: string;
+
+		if (this.$androidResourcesMigrationService.hasMigrated(appResourcesDirectoryPath)) {
+			stringsFilePath = path.join(this.getAppResourcesDestinationDirectoryPath(projectData), constants.MAIN_DIR, constants.RESOURCES_DIR, 'values', 'strings.xml');
+		} else {
+			stringsFilePath = path.join(this.getAppResourcesDestinationDirectoryPath(projectData), 'values', 'strings.xml');
+		}
 
-		const stringsFilePath = path.join(this.getAppResourcesDestinationDirectoryPath(projectData), 'values', 'strings.xml');
 		shell.sed('-i', /__NAME__/, projectData.projectName, stringsFilePath);
 		shell.sed('-i', /__TITLE_ACTIVITY__/, projectData.projectName, stringsFilePath);
 
@@ -317,33 +321,28 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	}
 
 	public async buildProject(projectRoot: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<void> {
-		if (this.canUseGradle(projectData)) {
-			const buildOptions = this.getBuildOptions(buildConfig, projectData);
-			if (this.$logger.getLevel() === "TRACE") {
-				buildOptions.unshift("--stacktrace");
-				buildOptions.unshift("--debug");
-			}
-			if (buildConfig.release) {
-				buildOptions.unshift("assembleRelease");
-			} else {
-				buildOptions.unshift("assembleDebug");
-			}
-
-			const handler = (data: any) => {
-				this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
-			};
-
-			await attachAwaitDetach(constants.BUILD_OUTPUT_EVENT_NAME,
-				this.$childProcess,
-				handler,
-				this.executeGradleCommand(this.getPlatformData(projectData).projectRoot,
-					buildOptions,
-					{ stdio: buildConfig.buildOutputStdio || "inherit" },
-					{ emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME }, throwError: true }));
+		const buildOptions = this.getBuildOptions(buildConfig, projectData);
+		if (this.$logger.getLevel() === "TRACE") {
+			buildOptions.unshift("--stacktrace");
+			buildOptions.unshift("--debug");
+		}
+		if (buildConfig.release) {
+			buildOptions.unshift("assembleRelease");
 		} else {
-			this.$errors.failWithoutHelp("Cannot complete build because this project is ANT-based." + EOL +
-				"Run `tns platform remove android && tns platform add android` to switch to Gradle and try again.");
+			buildOptions.unshift("assembleDebug");
 		}
+
+		const handler = (data: any) => {
+			this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
+		};
+
+		await attachAwaitDetach(constants.BUILD_OUTPUT_EVENT_NAME,
+			this.$childProcess,
+			handler,
+			this.executeGradleCommand(this.getPlatformData(projectData).projectRoot,
+				buildOptions,
+				{ stdio: buildConfig.buildOutputStdio || "inherit" },
+				{ emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME }, throwError: true }));
 	}
 
 	private getBuildOptions(settings: IAndroidBuildOptionsSettings, projectData: IProjectData): Array<string> {
@@ -391,7 +390,15 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	}
 
 	public ensureConfigurationFileInAppResources(projectData: IProjectData): void {
-		const originalAndroidManifestFilePath = path.join(projectData.appResourcesDirectoryPath, this.$devicePlatformsConstants.Android, this.getPlatformData(projectData).configurationFileName);
+		const appResourcesDirectoryPath = projectData.appResourcesDirectoryPath;
+		const appResourcesDirStructureHasMigrated = this.$androidResourcesMigrationService.hasMigrated(appResourcesDirectoryPath);
+		let originalAndroidManifestFilePath;
+
+		if (appResourcesDirStructureHasMigrated) {
+			originalAndroidManifestFilePath = path.join(appResourcesDirectoryPath, this.$devicePlatformsConstants.Android, "src", "main", this.getPlatformData(projectData).configurationFileName);
+		} else {
+			originalAndroidManifestFilePath = path.join(appResourcesDirectoryPath, this.$devicePlatformsConstants.Android, this.getPlatformData(projectData).configurationFileName);
+		}
 
 		const manifestExists = this.$fs.exists(originalAndroidManifestFilePath);
 
@@ -400,16 +407,13 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			return;
 		}
 		// Overwrite the AndroidManifest from runtime.
-		this.$fs.copyFile(originalAndroidManifestFilePath, this.getPlatformData(projectData).configurationFilePath);
+		if (!appResourcesDirStructureHasMigrated) {
+			this.$fs.copyFile(originalAndroidManifestFilePath, this.getPlatformData(projectData).configurationFilePath);
+		}
 	}
 
 	public prepareAppResources(appResourcesDirectoryPath: string, projectData: IProjectData): void {
-		const resourcesDirPath = path.join(appResourcesDirectoryPath, this.getPlatformData(projectData).normalizedPlatformName);
-		const valuesDirRegExp = /^values/;
-		const resourcesDirs = this.$fs.readDirectory(resourcesDirPath).filter(resDir => !resDir.match(valuesDirRegExp));
-		_.each(resourcesDirs, resourceDir => {
-			this.$fs.deleteDirectory(path.join(this.getAppResourcesDestinationDirectoryPath(projectData), resourceDir));
-		});
+		// Intentionally left empty
 	}
 
 	public async preparePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void> {
@@ -559,20 +563,6 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		// Nothing android specific to check yet.
 	}
 
-	private _canUseGradle: boolean;
-	private canUseGradle(projectData: IProjectData, frameworkVersion?: string): boolean {
-		if (!this._canUseGradle) {
-			if (!frameworkVersion) {
-				const frameworkInfoInProjectFile = this.$projectDataService.getNSValue(projectData.projectDir, this.getPlatformData(projectData).frameworkPackageName);
-				frameworkVersion = frameworkInfoInProjectFile && frameworkInfoInProjectFile.version;
-			}
-
-			this._canUseGradle = !frameworkVersion || semver.gte(frameworkVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE);
-		}
-
-		return this._canUseGradle;
-	}
-
 	private copy(projectRoot: string, frameworkDir: string, files: string, cpArg: string): void {
 		const paths = files.split(' ').map(p => path.join(frameworkDir, p));
 		shell.cp(cpArg, paths, projectRoot);
@@ -676,6 +666,24 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 
 		return semver.gte(normalizedPlatformVersion, androidStudioCompatibleTemplate);
 	}
+
+	private getLegacyAppResourcesDestinationDirPath(projectData: IProjectData): string {
+		const resourcePath: string[] = [constants.SRC_DIR, constants.MAIN_DIR, constants.RESOURCES_DIR];
+		if (this.isAndroidStudioTemplate) {
+			resourcePath.unshift(constants.APP_FOLDER_NAME);
+		}
+
+		return path.join(this.getPlatformData(projectData).projectRoot, ...resourcePath);
+	}
+
+	private getUpdatedAppResourcesDestinationDirPath(projectData: IProjectData): string {
+		const resourcePath: string[] = [constants.SRC_DIR];
+		if (this.isAndroidStudioTemplate) {
+			resourcePath.unshift(constants.APP_FOLDER_NAME);
+		}
+
+		return path.join(this.getPlatformData(projectData).projectRoot, ...resourcePath);
+	}
 }
 
 $injector.register("androidProjectService", AndroidProjectService);

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

@@ -0,0 +1,57 @@
+import * as path from "path";
+import * as shell from "shelljs";
+import * as constants from "../constants";
+
+export class AndroidResourcesMigrationService implements IAndroidResourcesMigrationService {
+	private static ANDROID_DIR = "Android";
+	private static ANDROID_DIR_TEMP = "Android-Updated";
+	private static ANDROID_DIR_OLD = "Android-Pre-v4";
+
+	constructor(private $fs: IFileSystem,
+		private $logger: ILogger,
+		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants) { }
+
+	public canMigrate(platformString: string): boolean {
+		return platformString.toLowerCase() === this.$devicePlatformsConstants.Android.toLowerCase();
+	}
+
+	public hasMigrated(appResourcesDir: string): boolean {
+		return this.$fs.exists(path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR, constants.SRC_DIR, constants.MAIN_DIR));
+	}
+
+	public async migrate(appResourcesDir: string): Promise<void> {
+		const originalAppResources = path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR);
+		const appResourcesDestination = path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR_TEMP);
+		const appMainSourceSet = path.join(appResourcesDestination, constants.SRC_DIR, constants.MAIN_DIR);
+		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));
+
+		const isDirectory = (source: string) => this.$fs.getLsStats(source).isDirectory();
+		const getDirectories = (source: string) =>
+			this.$fs.readDirectory(source).map(name => path.join(source, name)).filter(isDirectory);
+
+		this.$fs.copyFile(path.join(originalAppResources, "app.gradle"), path.join(appResourcesDestination, "app.gradle"));
+		this.$fs.copyFile(path.join(originalAppResources, constants.MANIFEST_FILE_NAME), path.join(appMainSourceSet, constants.MANIFEST_FILE_NAME));
+
+		const resourceDirectories = getDirectories(originalAppResources);
+
+		resourceDirectories.forEach(dir => {
+			this.$fs.copyFile(dir, appResourcesMainSourceSetResourcesDestination);
+		});
+
+		// rename the legacy app_resources to ANDROID_DIR_OLD
+		shell.mv(originalAppResources, path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR_OLD));
+		// move the new, updated app_resources to App_Resources/Android, as  the de facto resources
+		shell.mv(appResourcesDestination, originalAppResources);
+
+		this.$logger.out(`Successfully updated your project's application resources '/Android' directory structure.\nThe previous version of your Android application resources has been renamed to '/${AndroidResourcesMigrationService.ANDROID_DIR_OLD}'`);
+	}
+}
+
+$injector.register("androidResourcesMigrationService", AndroidResourcesMigrationService);