Merge pull request #230 from fealebenpae/library-add

Library add

Author: Mihail Slavchev

lib/bootstrap.ts

@@ -26,6 +26,7 @@ $injector.requireCommand("platform|*list", "./commands/list-platforms");
 $injector.requireCommand("platform|add", "./commands/add-platform");
 $injector.requireCommand("platform|remove", "./commands/remove-platform");
 $injector.requireCommand("platform|update", "./commands/update-platform");
+$injector.requireCommand("library|add", "./commands/add-library");
 $injector.requireCommand("run|ios", "./commands/run"); 
 $injector.requireCommand("run|android", "./commands/run");
 $injector.requireCommand("debug", "./commands/debug");

lib/commands/add-library.ts

@@ -0,0 +1,28 @@
+///<reference path="../.d.ts"/>
+"use strict";
+
+import path = require("path");
+import Future = require("fibers/future");
+
+export class AddLibraryCommand implements ICommand {
+    constructor(private $platformService: IPlatformService,
+                private $errors: IErrors) { }
+
+    allowedParameters: ICommandParameter[] = [];
+
+    execute(args: string[]): IFuture<void> {
+        var platform = args[0];
+        var libraryPath = path.resolve(args[1]);
+        return this.$platformService.addLibrary(platform, libraryPath);
+    }
+
+    canExecute(args: string[]): IFuture<boolean> {
+        if (args.length !== 2) {
+            this.$errors.fail("This command needs two parameters.");
+        }
+
+        this.$platformService.validatePlatformInstalled(args[0]);
+        return Future.fromResult(true);
+    }
+}
+$injector.registerCommand("library|add", AddLibraryCommand);

lib/definitions/libref.ts

@@ -0,0 +1,5 @@
+interface ILibRef {
+    idx: number;
+    path: string;
+    adjustedPath?: string;
+}

lib/definitions/osenv.d.ts

@@ -1,3 +1,3 @@
 declare module "osenv" {
 	function home(): string;
-}
+}

lib/definitions/platform.d.ts

@@ -13,6 +13,7 @@ interface IPlatformService {
 	deployOnEmulator(platform: string): IFuture<void>;
 	validatePlatformInstalled(platform: string): void;
 	validatePlatform(platform: string): void;
+	addLibrary(platform: string, libraryPath: string): IFuture<void>;
 }
 
 interface IPlatformData {

lib/definitions/project.d.ts

@@ -29,4 +29,5 @@ interface IPlatformProjectService {
 	prepareProject(platformData: IPlatformData): IFuture<string>;
 	buildProject(projectRoot: string): IFuture<void>;
 	isPlatformPrepared(projectRoot: string): IFuture<boolean>;
+	addLibrary(platformData: IPlatformData, libraryPath: string): IFuture<void>;
 }

lib/definitions/xcode.d.ts

@@ -0,0 +1,23 @@
+declare module "xcode" {
+    interface FrameworkOptions {
+        [key: string]: any;
+
+        customFramework?: boolean;
+
+        embed?: boolean;
+    }
+
+    class project {
+        constructor(filename: string);
+
+        parse(callback: () => void): void;
+        parseSync(): void;
+
+        writeSync(): string;
+
+        addFramework(filepath: string, options?: FrameworkOptions): void;
+        removeFramework(filePath: string, options?: FrameworkOptions): void;
+
+        updateBuildProperty(key: string, value: any): void;
+    }
+}

lib/services/android-project-service.ts

@@ -8,9 +8,12 @@ import options = require("../common/options");
 import constants = require("../constants");
 import hostInfo = require("../common/host-info");
 import helpers = require("../common/helpers");
+import fs = require("fs");
+import os = require("os");
 
 class AndroidProjectService implements IPlatformProjectService {
 	private SUPPORTED_TARGETS = ["android-17", "android-18", "android-19", "android-21"];
+	private static METADATA_DIRNAME = "__metadata";
 	private targetApi: string;
 
 	constructor(private $androidEmulatorServices: Mobile.IEmulatorPlatformServices,
@@ -118,19 +121,134 @@ class AndroidProjectService implements IPlatformProjectService {
 			return assetsDirectory;
 
 		}).future<string>()();
-	}
+    }
+
+    private updateMetadata(projectRoot: string): void {
+        var projMetadataDir = path.join(projectRoot, "assets", "metadata");
+        var libsmetadataDir = path.join(projectRoot, "../../lib", this.platformData.normalizedPlatformName, AndroidProjectService.METADATA_DIRNAME);
+        shell.cp("-f", path.join(libsmetadataDir, "*.dat"), projMetadataDir);
+    }
+
+    private generateMetadata(projectRoot: string): void {
+        var metadataGeneratorPath = path.join(__dirname, "../../resources/tools/metadata-generator.jar");
+        var libsFolder = path.join(projectRoot, "../../lib", this.platformData.normalizedPlatformName);
+		var metadataDirName = AndroidProjectService.METADATA_DIRNAME;
+        var outDir = path.join(libsFolder, metadataDirName);
+        this.$fs.ensureDirectoryExists(outDir).wait();
+
+		shell.cp("-f", path.join(__dirname, "../../resources/tools/android.jar"), libsFolder);
+		shell.cp("-f", path.join(__dirname, "../../resources/tools/android-support-v4.jar"), libsFolder);
+		shell.cp("-f", path.join(projectRoot, "libs/*.jar"), libsFolder);
+
+		this.spawn('java', ['-jar', metadataGeneratorPath, libsFolder, outDir]).wait();
+    }
 
 	public buildProject(projectRoot: string): IFuture<void> {
 		return (() => {
 			var buildConfiguration = options.release ? "release" : "debug";
-			var args = this.getAntArgs(buildConfiguration, projectRoot);
-			this.spawn('ant', args).wait();
+            var args = this.getAntArgs(buildConfiguration, projectRoot);
+			var argsSaved = this.getAntArgs(buildConfiguration, projectRoot);
+            this.spawn('ant', args).wait();
+            this.generateMetadata(projectRoot);
+            this.updateMetadata(projectRoot);
+            // build the project again in order to include the newly generated metadata
+			this.spawn('ant', argsSaved).wait();
 		}).future<void>()();
 	}
 
 	public isPlatformPrepared(projectRoot: string): IFuture<boolean> {
 		return this.$fs.exists(path.join(projectRoot, "assets", constants.APP_FOLDER_NAME));
-	}
+    }
+
+    private generateBuildFile(projDir: string, targetSdk: string): void {
+        this.$logger.info("Generate build.xml for %s", projDir);
+        var cmd = util.format("android update project -p %s --target %s --subprojects", projDir, targetSdk);
+        this.$childProcess.exec(cmd).wait();
+    }
+
+    private parseProjectProperties(projDir: string, destDir: string): void {
+        var projProp = path.join(projDir, "project.properties");
+
+        if (!this.$fs.exists(projProp).wait()) {
+            this.$logger.warn("File %s does not exist", projProp);
+            return;
+        }
+
+		var lines = this.$fs.readText(projProp, "utf-8").wait().split(os.EOL);
+
+		var regEx = /android\.library\.reference\.(\d+)=(.*)/;
+        lines.forEach(elem => {
+            var match = elem.match(regEx);
+            if (match) {
+                var libRef: ILibRef = { idx: parseInt(match[1]), path: match[2].trim() };
+                libRef.adjustedPath = this.$fs.isRelativePath(libRef.path) ? path.join(projDir, libRef.path) : libRef.path;
+                this.parseProjectProperties(libRef.adjustedPath, destDir);
+            }
+        });
+
+        this.$logger.info("Copying %s", projDir);
+        shell.cp("-Rf", projDir, destDir);
+
+        var targetDir = path.join(destDir, path.basename(projDir));
+        // TODO: parametrize targetSdk
+        var targetSdk = "android-17";
+        this.generateBuildFile(targetDir, targetSdk);
+    }
+
+    private getProjectReferences(projDir: string): ILibRef[]{
+        var projProp = path.join(projDir, "project.properties");
+
+		var lines = this.$fs.readText(projProp, "utf-8").wait().split(os.EOL);
+
+        var refs: ILibRef[] = [];
+
+		var regEx = /android\.library\.reference\.(\d+)=(.*)/;
+        lines.forEach(elem => {
+            var match = elem.match(regEx);
+            if (match) {
+                var libRef: ILibRef = { idx: parseInt(match[1]), path: match[2] };
+                libRef.adjustedPath = path.join(projDir, libRef.path);
+                refs.push(libRef);
+            }
+        });
+
+        return refs;
+    }
+
+    private updateProjectReferences(projDir: string, libraryPath: string): void {
+        var refs = this.getProjectReferences(projDir);
+		var maxIdx = refs.length > 0 ? _.max(refs, r => r.idx).idx : 0;
+
+        var relLibDir = path.relative(projDir, libraryPath).split("\\").join("/");
+
+        var libRefExists = _.any(refs, r => path.normalize(r.path) === path.normalize(relLibDir));
+
+        if (!libRefExists) {
+            var projRef = util.format("%sandroid.library.reference.%d=%s", os.EOL, maxIdx + 1, relLibDir);
+            var projProp = path.join(projDir, "project.properties");
+            fs.appendFileSync(projProp, projRef, { encoding: "utf-8" });
+        }
+    }
+
+	public addLibrary(platformData: IPlatformData, libraryPath: string): IFuture<void> {
+		return (() => {
+			var name = path.basename(libraryPath);
+			var projDir = this.$projectData.projectDir;
+			var targetPath = path.join(projDir, "lib", platformData.normalizedPlatformName);
+			this.$fs.ensureDirectoryExists(targetPath).wait();
+
+			this.parseProjectProperties(libraryPath, targetPath);
+
+			shell.cp("-f", path.join(libraryPath, "*.jar"), targetPath);
+			var projectLibsDir = path.join(platformData.projectRoot, "libs");
+			this.$fs.ensureDirectoryExists(projectLibsDir).wait();
+			shell.cp("-f", path.join(libraryPath, "*.jar"), projectLibsDir);
+
+			var targetLibPath = path.join(targetPath, path.basename(libraryPath));
+
+			this.updateProjectReferences(platformData.projectRoot, targetLibPath);
+		}).future<void>()();
+    }
 
 	public getFrameworkFilesExtensions(): string[] {
 		return [".jar", ".dat"];
@@ -325,4 +443,4 @@ class AndroidProjectService implements IPlatformProjectService {
 		}).future<void>()();
 	}
 }
-$injector.register("androidProjectService", AndroidProjectService);
+$injector.register("androidProjectService", AndroidProjectService);

lib/services/ios-project-service.ts

@@ -5,19 +5,21 @@ import Future = require("fibers/future");
 import path = require("path");
 import shell = require("shelljs");
 import util = require("util");
+import xcode = require("xcode");
 import constants = require("./../constants");
 import helpers = require("./../common/helpers");
 import options = require("../common/options");
 
 class IOSProjectService implements  IPlatformProjectService {
 	private static XCODE_PROJECT_EXT_NAME = ".xcodeproj";
-	private static XCODEBUILD_MIN_VERSION = "5.0";
+	private static XCODEBUILD_MIN_VERSION = "6.0";
 	private static IOS_PROJECT_NAME_PLACEHOLDER = "__PROJECT_NAME__";
 
 	constructor(private $projectData: IProjectData,
 		private $fs: IFileSystem,
 		private $childProcess: IChildProcess,
 		private $errors: IErrors,
+		private $logger: ILogger,
 		private $iOSEmulatorServices: Mobile.IEmulatorPlatformServices) { }
 
 	public get platformData(): IPlatformData {
@@ -169,6 +171,93 @@ class IOSProjectService implements  IPlatformProjectService {
 		return this.$fs.exists(path.join(projectRoot, this.$projectData.projectName, constants.APP_FOLDER_NAME));
 	}
 
+    public addLibrary(platformData: IPlatformData, libraryPath: string): IFuture<void> {
+        return (() => {
+            this.validateDynamicFramework(libraryPath).wait();
+            var umbrellaHeader = this.getUmbrellaHeaderFromDynamicFramework(libraryPath).wait();
+
+            var frameworkName = path.basename(libraryPath, path.extname(libraryPath));
+            var targetPath = path.join(this.$projectData.projectDir, "lib", platformData.normalizedPlatformName, frameworkName);
+            this.$fs.ensureDirectoryExists(targetPath).wait();
+            shell.cp("-R", libraryPath, targetPath);
+
+            this.generateFrameworkMetadata(platformData.projectRoot, targetPath, frameworkName, umbrellaHeader).wait();
+
+            var pbxProjPath = path.join(platformData.projectRoot, this.$projectData.projectName + ".xcodeproj", "project.pbxproj");
+            var project = new xcode.project(pbxProjPath);
+            project.parseSync();
+
+            project.addFramework(path.join(targetPath, frameworkName + ".framework"), { customFramework: true, embed: true });
+            project.updateBuildProperty("IPHONEOS_DEPLOYMENT_TARGET", "8.0");
+            this.$fs.writeFile(pbxProjPath, project.writeSync()).wait();
+            this.$logger.info("The iOS Deployment Target is now 8.0 in order to support Cocoa Touch Frameworks.");
+        }).future<void>()();
+    }
+
+    private validateDynamicFramework(libraryPath: string): IFuture<void> {
+        return (() => {
+            var infoPlistPath = path.join(libraryPath, "Info.plist");
+            if (!this.$fs.exists(infoPlistPath).wait()) {
+                this.$errors.failWithoutHelp("The bundle at %s does not contain an Info.plist file.", libraryPath);
+            }
+
+            var packageType = this.$childProcess.exec('/usr/libexec/PlistBuddy -c "Print :CFBundlePackageType" ' + infoPlistPath).wait().trim();
+            if (packageType !== "FMWK") {
+                this.$errors.failWithoutHelp("The bundle at %s does not appear to be a dynamic framework.", libraryPath);
+            }
+        }).future<void>()();
+    }
+
+    private getUmbrellaHeaderFromDynamicFramework(libraryPath: string): IFuture<string> {
+        return (() => {
+            var modulemapPath = path.join(libraryPath, "Modules", "module.modulemap");
+            if (!this.$fs.exists(modulemapPath).wait()) {
+				this.$errors.failWithoutHelp("The framework at %s does not contain a module.modulemap file.", modulemapPath);
+            }
+
+            var modulemap = this.$fs.readText(modulemapPath).wait();
+            var umbrellaRegex = /umbrella header "(.+\.h)"/g;
+            var match = umbrellaRegex.exec(modulemap);
+            if (!match) {
+                this.$errors.failWithoutHelp("The modulemap at %s does not specify an umbrella header.", modulemapPath);
+            }
+
+            return match[1];
+        }).future<string>()();
+    }
+
+    private generateFrameworkMetadata(projectRoot: string, frameworkDir: string, frameworkName: string, umbrellaHeader: string): IFuture<void> {
+        return (() => {
+            if (!this.$fs.exists("/usr/local/lib/libmonoboehm-2.0.1.dylib").wait()) {
+                this.$errors.failWithoutHelp("NativeScript needs Mono 3.10 or newer installed in /usr/local");
+            }
+
+            var yamlOut = path.join(frameworkDir, "Metadata");
+            this.$fs.createDirectory(yamlOut).wait();
+
+            var tempHeader = path.join(yamlOut, "Metadata.h");
+            this.$fs.writeFile(tempHeader, util.format("#import <%s/%s>", frameworkName, umbrellaHeader)).wait();
+
+            this.$logger.info("Generating metadata for %s.framework. This can take a minute.", frameworkName);
+            var sdkPath = this.$childProcess.exec("xcrun -sdk iphoneos --show-sdk-path").wait().trim();
+            // MetadataGenerator P/Invokes libclang.dylib, so we need to instruct the Mach-O loader where to find it.
+            // Without this Mono will fail with a DllNotFoundException.
+            // Once the MetadataGenerator is rewritten in C++ and starts linking Clang statically, this will become superfluous.
+            var generatorExecOptions = {
+                env: {
+                    DYLD_FALLBACK_LIBRARY_PATH: this.$childProcess.exec("xcode-select -p").wait().trim() + "/Toolchains/XcodeDefault.xctoolchain/usr/lib"
+                }
+            };
+            this.$childProcess.exec(util.format('%s/Metadata/MetadataGenerator -s %s -u %s -o %s -cflags="-F%s"', projectRoot, sdkPath, tempHeader, yamlOut, frameworkDir), generatorExecOptions).wait();
+
+			var metadataFileName = frameworkName + ".yaml";
+			this.$fs.copyFile(path.join(yamlOut, "Metadata-armv7", metadataFileName), path.join(projectRoot, "Metadata", "Metadata-armv7", metadataFileName)).wait();
+			this.$fs.copyFile(path.join(yamlOut, "Metadata-arm64", metadataFileName), path.join(projectRoot, "Metadata", "Metadata-arm64", metadataFileName)).wait();
+
+            this.$fs.deleteDirectory(yamlOut).wait();
+        }).future<void>()();
+    }
+
 	private replaceFileContent(file: string): IFuture<void> {
 		return (() => {
 			var fileContent = this.$fs.readText(file).wait();
@@ -186,4 +275,4 @@ class IOSProjectService implements  IPlatformProjectService {
 		}).future<void>()();
 	}
 }
-$injector.register("iOSProjectService", IOSProjectService);
+$injector.register("iOSProjectService", IOSProjectService);

lib/services/platform-service.ts

@@ -322,6 +322,17 @@ export class PlatformService implements IPlatformService {
 		}
 	}
 
+    public addLibrary(platform: string, libraryPath: string): IFuture<void> {
+        return (() => {
+            if (!this.$fs.exists(libraryPath).wait()) {
+                this.$errors.fail("The path %s does not exist", libraryPath);
+            } else {
+                var platformData = this.$platformsData.getPlatformData(platform);
+                platformData.platformProjectService.addLibrary(platformData, libraryPath).wait();
+            }
+        }).future<void>()();
+    }
+
 	private isValidPlatform(platform: string) {
 		return this.$platformsData.getPlatformData(platform);
 	}