"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var path = require("path");
var shell = require("shelljs");
var Future = require("fibers/future");
var constants = require("../constants");
var semver = require("semver");
var projectServiceBaseLib = require("./platform-project-service-base");
var device_android_debug_bridge_1 = require("../common/mobile/android/device-android-debug-bridge");
var android_device_hash_service_1 = require("../common/mobile/android/android-device-hash-service");
var os_1 = require("os");
var AndroidProjectService = (function (_super) {
    __extends(AndroidProjectService, _super);
    function AndroidProjectService($androidEmulatorServices, $androidToolsInfo, $childProcess, $errors, $fs, $hostInfo, $logger, $options, $projectData, $projectDataService, $sysInfo, $mobileHelper, $injector, $pluginVariablesService, $deviceAppDataFactory, $devicePlatformsConstants, $projectTemplatesService, $xmlValidator, $config, $npm) {
        _super.call(this, $fs, $projectData, $projectDataService);
        this.$androidEmulatorServices = $androidEmulatorServices;
        this.$androidToolsInfo = $androidToolsInfo;
        this.$childProcess = $childProcess;
        this.$errors = $errors;
        this.$hostInfo = $hostInfo;
        this.$logger = $logger;
        this.$options = $options;
        this.$sysInfo = $sysInfo;
        this.$mobileHelper = $mobileHelper;
        this.$injector = $injector;
        this.$pluginVariablesService = $pluginVariablesService;
        this.$deviceAppDataFactory = $deviceAppDataFactory;
        this.$devicePlatformsConstants = $devicePlatformsConstants;
        this.$projectTemplatesService = $projectTemplatesService;
        this.$xmlValidator = $xmlValidator;
        this.$config = $config;
        this.$npm = $npm;
        this._platformData = null;
        this._androidProjectPropertiesManagers = Object.create(null);
    }
    Object.defineProperty(AndroidProjectService.prototype, "platformData", {
        get: function () {
            if (!this._platformData) {
                var projectRoot = path.join(this.$projectData.platformsDir, "android");
                var packageName = this.getProjectNameFromId();
                this._platformData = {
                    frameworkPackageName: "tns-android",
                    normalizedPlatformName: "Android",
                    appDestinationDirectoryPath: path.join(projectRoot, "src", "main", "assets"),
                    platformProjectService: this,
                    emulatorServices: this.$androidEmulatorServices,
                    projectRoot: projectRoot,
                    deviceBuildOutputPath: path.join(projectRoot, "build", "outputs", "apk"),
                    validPackageNamesForDevice: [
                        (packageName + "-debug.apk"),
                        (packageName + "-release.apk"),
                        (this.$projectData.projectName + "-debug.apk"),
                        (this.$projectData.projectName + "-release.apk")
                    ],
                    frameworkFilesExtensions: [".jar", ".dat", ".so"],
                    configurationFileName: "AndroidManifest.xml",
                    configurationFilePath: path.join(projectRoot, "src", "main", "AndroidManifest.xml"),
                    relativeToFrameworkConfigurationFilePath: path.join("src", "main", "AndroidManifest.xml"),
                    fastLivesyncFileExtensions: [".jpg", ".gif", ".png", ".bmp", ".webp"]
                };
            }
            return this._platformData;
        },
        enumerable: true,
        configurable: true
    });
    AndroidProjectService.prototype.getAppResourcesDestinationDirectoryPath = function (frameworkVersion) {
        var _this = this;
        return (function () {
            if (_this.canUseGradle(frameworkVersion).wait()) {
                return path.join(_this.platformData.projectRoot, "src", "main", "res");
            }
            return path.join(_this.platformData.projectRoot, "res");
        }).future()();
    };
    AndroidProjectService.prototype.validate = function () {
        var _this = this;
        return (function () {
            _this.validatePackageName(_this.$projectData.projectId);
            _this.validateProjectName(_this.$projectData.projectName);
            _this.$androidToolsInfo.getPathToAndroidExecutable({ showWarningsAsErrors: true }).wait();
            var javaCompilerVersion = _this.$sysInfo.getJavaCompilerVersion().wait();
            _this.$androidToolsInfo.validateJavacVersion(javaCompilerVersion, { showWarningsAsErrors: true }).wait();
        }).future()();
    };
    AndroidProjectService.prototype.createProject = function (frameworkDir, frameworkVersion, pathToTemplate) {
        var _this = this;
        return (function () {
            if (semver.lt(frameworkVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
                _this.$errors.failWithoutHelp("The NativeScript CLI requires Android runtime " + AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE + " or later to work properly.");
            }
            _this.$fs.ensureDirectoryExists(_this.platformData.projectRoot).wait();
            _this.$androidToolsInfo.validateInfo({ showWarningsAsErrors: true, validateTargetSdk: true }).wait();
            var androidToolsInfo = _this.$androidToolsInfo.getToolsInfo().wait();
            var targetSdkVersion = androidToolsInfo.targetSdkVersion;
            _this.$logger.trace("Using Android SDK '" + targetSdkVersion + "'.");
            if (_this.$options.symlink) {
                _this.symlinkDirectory("libs", _this.platformData.projectRoot, frameworkDir).wait();
            }
            else {
                _this.copy(_this.platformData.projectRoot, frameworkDir, "libs", "-R");
            }
            if (pathToTemplate) {
                var mainPath = path.join(_this.platformData.projectRoot, "src", "main");
                _this.$fs.createDirectory(mainPath).wait();
                shell.cp("-R", path.join(path.resolve(pathToTemplate), "*"), mainPath);
            }
            else {
                _this.copy(_this.platformData.projectRoot, frameworkDir, "src", "-R");
            }
            _this.copy(_this.platformData.projectRoot, frameworkDir, "build.gradle settings.gradle gradle.properties build-tools", "-Rf");
            if (_this.useGradleWrapper(frameworkDir)) {
                _this.copy(_this.platformData.projectRoot, frameworkDir, "gradle", "-R");
                _this.copy(_this.platformData.projectRoot, frameworkDir, "gradlew gradlew.bat", "-f");
            }
            _this.cleanResValues(targetSdkVersion, frameworkVersion).wait();
            var npmConfig = {
                "save": true,
                "save-dev": true,
                "save-exact": true,
                "silent": true
            };
            var projectPackageJson = _this.$fs.readJson(_this.$projectData.projectFilePath).wait();
            _.each(AndroidProjectService.REQUIRED_DEV_DEPENDENCIES, function (dependency) {
                var dependencyVersionInProject = (projectPackageJson.dependencies && projectPackageJson.dependencies[dependency.name]) ||
                    (projectPackageJson.devDependencies && projectPackageJson.devDependencies[dependency.name]);
                if (!dependencyVersionInProject) {
                    _this.$npm.install(dependency.name + "@" + dependency.version, _this.$projectData.projectDir, npmConfig).wait();
                }
                else {
                    var cleanedVerson = semver.clean(dependencyVersionInProject);
                    if (!cleanedVerson) {
                        var pathToPluginPackageJson = path.join(_this.$projectData.projectDir, constants.NODE_MODULES_FOLDER_NAME, dependency.name, constants.PACKAGE_JSON_FILE_NAME);
                        dependencyVersionInProject = _this.$fs.exists(pathToPluginPackageJson).wait() && _this.$fs.readJson(pathToPluginPackageJson).wait().version;
                    }
                    if (!semver.satisfies(dependencyVersionInProject || cleanedVerson, dependency.version)) {
                        _this.$errors.failWithoutHelp("Your project have installed " + dependency.name + " version " + cleanedVerson + " but Android platform requires version " + dependency.version + ".");
                    }
                }
            });
        }).future()();
    };
    AndroidProjectService.prototype.useGradleWrapper = function (frameworkDir) {
        var gradlew = path.join(frameworkDir, "gradlew");
        return this.$fs.exists(gradlew).wait();
    };
    AndroidProjectService.prototype.cleanResValues = function (targetSdkVersion, frameworkVersion) {
        var _this = this;
        return (function () {
            var resDestinationDir = _this.getAppResourcesDestinationDirectoryPath(frameworkVersion).wait();
            var directoriesInResFolder = _this.$fs.readDirectory(resDestinationDir).wait();
            var directoriesToClean = directoriesInResFolder
                .map(function (dir) {
                return {
                    dirName: dir,
                    sdkNum: parseInt(dir.substr(AndroidProjectService.VALUES_VERSION_DIRNAME_PREFIX.length))
                };
            })
                .filter(function (dir) { return dir.dirName.match(AndroidProjectService.VALUES_VERSION_DIRNAME_PREFIX)
                && dir.sdkNum
                && (!targetSdkVersion || (targetSdkVersion < dir.sdkNum)); })
                .map(function (dir) { return path.join(resDestinationDir, dir.dirName); });
            _this.$logger.trace("Directories to clean:");
            _this.$logger.trace(directoriesToClean);
            Future.wait(_.map(directoriesToClean, function (dir) { return _this.$fs.deleteDirectory(dir); }));
        }).future()();
    };
    AndroidProjectService.prototype.interpolateData = function () {
        var _this = this;
        return (function () {
            _this.interpolateConfigurationFile().wait();
            var stringsFilePath = path.join(_this.getAppResourcesDestinationDirectoryPath().wait(), 'values', 'strings.xml');
            shell.sed('-i', /__NAME__/, _this.$projectData.projectName, stringsFilePath);
            shell.sed('-i', /__TITLE_ACTIVITY__/, _this.$projectData.projectName, stringsFilePath);
            var gradleSettingsFilePath = path.join(_this.platformData.projectRoot, "settings.gradle");
            shell.sed('-i', /__PROJECT_NAME__/, _this.getProjectNameFromId(), gradleSettingsFilePath);
            var userAppGradleFilePath = path.join(_this.$projectData.appResourcesDirectoryPath, _this.$devicePlatformsConstants.Android, "app.gradle");
            shell.sed('-i', /__PACKAGE__/, _this.$projectData.projectId, userAppGradleFilePath);
        }).future()();
    };
    AndroidProjectService.prototype.interpolateConfigurationFile = function () {
        var _this = this;
        return (function () {
            var manifestPath = _this.platformData.configurationFilePath;
            shell.sed('-i', /__PACKAGE__/, _this.$projectData.projectId, manifestPath);
            shell.sed('-i', /__APILEVEL__/, _this.$options.sdk || _this.$androidToolsInfo.getToolsInfo().wait().compileSdkVersion.toString(), manifestPath);
        }).future()();
    };
    AndroidProjectService.prototype.getProjectNameFromId = function () {
        var id;
        if (this.$projectData && this.$projectData.projectId) {
            id = this.$projectData.projectId.split(".")[2];
        }
        return id;
    };
    AndroidProjectService.prototype.afterCreateProject = function (projectRoot) {
        return Future.fromResult();
    };
    AndroidProjectService.prototype.canUpdatePlatform = function (currentVersion, newVersion) {
        return Future.fromResult(true);
    };
    AndroidProjectService.prototype.updatePlatform = function (currentVersion, newVersion, canUpdate, addPlatform, removePlatforms) {
        var _this = this;
        return (function () {
            if (semver.eq(newVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
                var platformLowercase = _this.platformData.normalizedPlatformName.toLowerCase();
                removePlatforms([platformLowercase.split("@")[0]]).wait();
                addPlatform(platformLowercase).wait();
                return false;
            }
            return true;
        }).future()();
    };
    AndroidProjectService.prototype.buildProject = function (projectRoot, buildConfig) {
        var _this = this;
        return (function () {
            if (_this.canUseGradle().wait()) {
                var buildOptions = _this.getBuildOptions();
                if (_this.$logger.getLevel() === "TRACE") {
                    buildOptions.unshift("--stacktrace");
                    buildOptions.unshift("--debug");
                }
                buildOptions.unshift("buildapk");
                var gradleBin = _this.useGradleWrapper(projectRoot) ? path.join(projectRoot, "gradlew") : "gradle";
                if (_this.$hostInfo.isWindows) {
                    gradleBin += ".bat";
                }
                _this.spawn(gradleBin, buildOptions, { stdio: "inherit", cwd: _this.platformData.projectRoot }).wait();
            }
            else {
                _this.$errors.failWithoutHelp("Cannot complete build because this project is ANT-based." + os_1.EOL +
                    "Run `tns platform remove android && tns platform add android` to switch to Gradle and try again.");
            }
        }).future()();
    };
    AndroidProjectService.prototype.getBuildOptions = function () {
        this.$androidToolsInfo.validateInfo({ showWarningsAsErrors: true, validateTargetSdk: true }).wait();
        var androidToolsInfo = this.$androidToolsInfo.getToolsInfo().wait();
        var compileSdk = androidToolsInfo.compileSdkVersion;
        var targetSdk = this.getTargetFromAndroidManifest().wait() || compileSdk;
        var buildToolsVersion = androidToolsInfo.buildToolsVersion;
        var appCompatVersion = androidToolsInfo.supportRepositoryVersion;
        var buildOptions = [
            ("-PcompileSdk=android-" + compileSdk),
            ("-PtargetSdk=" + targetSdk),
            ("-PbuildToolsVersion=" + buildToolsVersion),
            ("-PsupportVersion=" + appCompatVersion),
        ];
        if (this.$options.release) {
            buildOptions.push("-Prelease");
            buildOptions.push("-PksPath=" + path.resolve(this.$options.keyStorePath));
            buildOptions.push("-Palias=" + this.$options.keyStoreAlias);
            buildOptions.push("-Ppassword=" + this.$options.keyStoreAliasPassword);
            buildOptions.push("-PksPassword=" + this.$options.keyStorePassword);
        }
        return buildOptions;
    };
    AndroidProjectService.prototype.buildForDeploy = function (projectRoot, buildConfig) {
        return this.buildProject(projectRoot, buildConfig);
    };
    AndroidProjectService.prototype.isPlatformPrepared = function (projectRoot) {
        return this.$fs.exists(path.join(this.platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME));
    };
    AndroidProjectService.prototype.getFrameworkFilesExtensions = function () {
        return [".jar", ".dat"];
    };
    AndroidProjectService.prototype.prepareProject = function () {
        return Future.fromResult();
    };
    AndroidProjectService.prototype.ensureConfigurationFileInAppResources = function () {
        var _this = this;
        return (function () {
            var originalAndroidManifestFilePath = path.join(_this.$projectData.appResourcesDirectoryPath, _this.$devicePlatformsConstants.Android, _this.platformData.configurationFileName);
            var manifestExists = _this.$fs.exists(originalAndroidManifestFilePath).wait();
            if (!manifestExists) {
                _this.$logger.warn('No manifest found in ' + originalAndroidManifestFilePath);
                return;
            }
            _this.$fs.copyFile(originalAndroidManifestFilePath, _this.platformData.configurationFilePath).wait();
        }).future()();
    };
    AndroidProjectService.prototype.prepareAppResources = function (appResourcesDirectoryPath) {
        var _this = this;
        return (function () {
            var resourcesDirPath = path.join(appResourcesDirectoryPath, _this.platformData.normalizedPlatformName);
            var valuesDirRegExp = /^values/;
            var resourcesDirs = _this.$fs.readDirectory(resourcesDirPath).wait().filter(function (resDir) { return !resDir.match(valuesDirRegExp); });
            _.each(resourcesDirs, function (resourceDir) {
                _this.$fs.deleteDirectory(path.join(_this.getAppResourcesDestinationDirectoryPath().wait(), resourceDir)).wait();
            });
        }).future()();
    };
    AndroidProjectService.prototype.preparePluginNativeCode = function (pluginData) {
        var _this = this;
        return (function () {
            var pluginPlatformsFolderPath = _this.getPluginPlatformsFolderPath(pluginData, AndroidProjectService.ANDROID_PLATFORM_NAME);
            _this.processResourcesFromPlugin(pluginData, pluginPlatformsFolderPath).wait();
        }).future()();
    };
    AndroidProjectService.prototype.processConfigurationFilesFromAppResources = function () {
        return Future.fromResult();
    };
    AndroidProjectService.prototype.processResourcesFromPlugin = function (pluginData, pluginPlatformsFolderPath) {
        var _this = this;
        return (function () {
            var configurationsDirectoryPath = path.join(_this.platformData.projectRoot, "configurations");
            _this.$fs.ensureDirectoryExists(configurationsDirectoryPath).wait();
            var pluginConfigurationDirectoryPath = path.join(configurationsDirectoryPath, pluginData.name);
            if (_this.$fs.exists(pluginPlatformsFolderPath).wait()) {
                _this.$fs.ensureDirectoryExists(pluginConfigurationDirectoryPath).wait();
                var resourcesDestinationDirectoryPath = path.join(_this.platformData.projectRoot, "src", pluginData.name);
                _this.$fs.ensureDirectoryExists(resourcesDestinationDirectoryPath).wait();
                shell.cp("-Rf", path.join(pluginPlatformsFolderPath, "*"), resourcesDestinationDirectoryPath);
                (_this.$fs.enumerateFilesInDirectorySync(resourcesDestinationDirectoryPath, function (file) { return _this.$fs.getFsStats(file).wait().isDirectory() || path.extname(file) === constants.XML_FILE_EXTENSION; }) || [])
                    .forEach(function (file) {
                    _this.$logger.trace("Interpolate data for plugin file: " + file);
                    _this.$pluginVariablesService.interpolate(pluginData, file).wait();
                });
            }
            var includeGradleFilePath = path.join(pluginPlatformsFolderPath, "include.gradle");
            if (_this.$fs.exists(includeGradleFilePath).wait()) {
                shell.cp("-f", includeGradleFilePath, pluginConfigurationDirectoryPath);
            }
        }).future()();
    };
    AndroidProjectService.prototype.removePluginNativeCode = function (pluginData) {
        var _this = this;
        return (function () {
            try {
                _this.$fs.deleteDirectory(path.join(_this.platformData.projectRoot, "configurations", pluginData.name)).wait();
                _this.$fs.deleteDirectory(path.join(_this.platformData.projectRoot, "src", pluginData.name)).wait();
            }
            catch (e) {
                if (e.code === "ENOENT") {
                    _this.$logger.debug("No native code jars found: " + e.message);
                }
                else {
                    throw e;
                }
            }
        }).future()();
    };
    AndroidProjectService.prototype.afterPrepareAllPlugins = function () {
        return Future.fromResult();
    };
    AndroidProjectService.prototype.beforePrepareAllPlugins = function () {
        if (!this.$config.debugLivesync) {
            var buildOptions = this.getBuildOptions();
            buildOptions.unshift("clean");
            var projectRoot = this.platformData.projectRoot;
            var gradleBin = this.useGradleWrapper(projectRoot) ? path.join(projectRoot, "gradlew") : "gradle";
            if (this.$hostInfo.isWindows) {
                gradleBin += ".bat";
            }
            this.spawn(gradleBin, buildOptions, { stdio: "inherit", cwd: this.platformData.projectRoot }).wait();
        }
        return Future.fromResult();
    };
    AndroidProjectService.prototype.deploy = function (deviceIdentifier) {
        var _this = this;
        return (function () {
            var adb = _this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
            var deviceRootPath = "/data/local/tmp/" + _this.$projectData.projectId;
            adb.executeShellCommand(["rm", "-rf", _this.$mobileHelper.buildDevicePath(deviceRootPath, "fullsync"),
                _this.$mobileHelper.buildDevicePath(deviceRootPath, "sync"),
                _this.$mobileHelper.buildDevicePath(deviceRootPath, "removedsync")]).wait();
            var projectFilesManager = _this.$injector.resolve("projectFilesManager");
            var devicesService = _this.$injector.resolve("devicesService");
            var device = _.find(devicesService.getDevicesForPlatform(_this.platformData.normalizedPlatformName), function (d) { return d.deviceInfo.identifier === deviceIdentifier; });
            var deviceAppData = _this.$deviceAppDataFactory.create(_this.$projectData.projectId, _this.platformData.normalizedPlatformName, device);
            var localToDevicePaths = projectFilesManager.createLocalToDevicePaths(deviceAppData, path.join(_this.platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME));
            var deviceHashService = _this.$injector.resolve(android_device_hash_service_1.AndroidDeviceHashService, { adb: adb, appIdentifier: _this.$projectData.projectId });
            deviceHashService.uploadHashFileToDevice(localToDevicePaths).wait();
        }).future()();
    };
    AndroidProjectService.prototype.canUseGradle = function (frameworkVersion) {
        var _this = this;
        return (function () {
            if (!_this._canUseGradle) {
                if (!frameworkVersion) {
                    _this.$projectDataService.initialize(_this.$projectData.projectDir);
                    var frameworkInfoInProjectFile = _this.$projectDataService.getValue(_this.platformData.frameworkPackageName).wait();
                    frameworkVersion = frameworkInfoInProjectFile && frameworkInfoInProjectFile.version;
                }
                _this._canUseGradle = !frameworkVersion || semver.gte(frameworkVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE);
            }
            return _this._canUseGradle;
        }).future()();
    };
    AndroidProjectService.prototype.copy = function (projectRoot, frameworkDir, files, cpArg) {
        var paths = files.split(' ').map(function (p) { return path.join(frameworkDir, p); });
        shell.cp(cpArg, paths, projectRoot);
    };
    AndroidProjectService.prototype.spawn = function (command, args, opts) {
        return this.$childProcess.spawnFromEvent(command, args, "close", opts || { stdio: "inherit" });
    };
    AndroidProjectService.prototype.validatePackageName = function (packageName) {
        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");
        }
        if (/\b[Cc]lass\b/.test(packageName)) {
            this.$errors.fail("class is a reserved word");
        }
    };
    AndroidProjectService.prototype.validateProjectName = function (projectName) {
        if (projectName === '') {
            this.$errors.fail("Project name cannot be empty");
        }
        if (/^[0-9]/.test(projectName)) {
            this.$errors.fail("Project name must not begin with a number");
        }
    };
    AndroidProjectService.prototype.getTargetFromAndroidManifest = function () {
        var _this = this;
        return (function () {
            var versionInManifest;
            if (_this.$fs.exists(_this.platformData.configurationFilePath).wait()) {
                var targetFromAndroidManifest = _this.$fs.readText(_this.platformData.configurationFilePath).wait();
                if (targetFromAndroidManifest) {
                    var match = targetFromAndroidManifest.match(/.*?android:targetSdkVersion=\"(.*?)\"/);
                    if (match && match[1]) {
                        versionInManifest = match[1];
                    }
                }
            }
            return versionInManifest;
        }).future()();
    };
    AndroidProjectService.prototype.symlinkDirectory = function (directoryName, projectRoot, frameworkDir) {
        var _this = this;
        return (function () {
            _this.$fs.createDirectory(path.join(projectRoot, directoryName)).wait();
            var directoryContent = _this.$fs.readDirectory(path.join(frameworkDir, directoryName)).wait();
            _.each(directoryContent, function (file) {
                var sourceFilePath = path.join(frameworkDir, directoryName, file);
                var destinationFilePath = path.join(projectRoot, directoryName, file);
                if (_this.$fs.getFsStats(sourceFilePath).wait().isFile()) {
                    _this.$fs.symlink(sourceFilePath, destinationFilePath).wait();
                }
                else {
                    _this.$fs.symlink(sourceFilePath, destinationFilePath, "dir").wait();
                }
            });
        }).future()();
    };
    AndroidProjectService.VALUES_DIRNAME = "values";
    AndroidProjectService.VALUES_VERSION_DIRNAME_PREFIX = AndroidProjectService.VALUES_DIRNAME + "-v";
    AndroidProjectService.ANDROID_PLATFORM_NAME = "android";
    AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE = "1.3.0";
    AndroidProjectService.REQUIRED_DEV_DEPENDENCIES = [
        { name: "babel-traverse", version: "^6.4.5" },
        { name: "babel-types", version: "^6.4.5" },
        { name: "babylon", version: "^6.4.5" },
        { name: "lazy", version: "^1.0.11" }
    ];
    return AndroidProjectService;
}(projectServiceBaseLib.PlatformProjectServiceBase));
exports.AndroidProjectService = AndroidProjectService;
$injector.register("androidProjectService", AndroidProjectService);
