@akylas/nativescript-cli 8.7.2

package/lib/services/ios-provision-service.js

@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSProvisionService = void 0;
+const mobileprovision = require("ios-mobileprovision-finder");
+const helpers_1 = require("../common/helpers");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+];
+function formatDate(date) {
+    return `${date.getDay()} ${months[date.getMonth()]} ${date.getFullYear()}`;
+}
+class IOSProvisionService {
+    constructor($logger, $options, $devicesService, $mobileHelper) {
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$devicesService = $devicesService;
+        this.$mobileHelper = $mobileHelper;
+    }
+    pick(uuidOrName, projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const match = (yield this.queryProvisioningProfilesAndDevices(projectId))
+                .match;
+            return (match.eligible.find((prov) => prov.UUID === uuidOrName) ||
+                match.eligible.find((prov) => prov.Name === uuidOrName) ||
+                match.nonEligible.find((prov) => prov.UUID === uuidOrName) ||
+                match.nonEligible.find((prov) => prov.Name === uuidOrName));
+        });
+    }
+    listProvisions(projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.queryProvisioningProfilesAndDevices(projectId);
+            const devices = data.devices;
+            const match = data.match;
+            function formatSupportedDeviceCount(prov) {
+                if (devices.length > 0 && prov.Type === "Development") {
+                    return (prov.ProvisionedDevices.filter((device) => devices.indexOf(device) >= 0).length +
+                        "/" +
+                        devices.length +
+                        " targets");
+                }
+                else {
+                    return "";
+                }
+            }
+            function formatTotalDeviceCount(prov) {
+                if (prov.Type === "Development" && prov.ProvisionedDevices) {
+                    return prov.ProvisionedDevices.length + " total";
+                }
+                else if (prov.Type === "AdHoc") {
+                    return "all";
+                }
+                else {
+                    return "";
+                }
+            }
+            const table = (0, helpers_1.createTable)([
+                "Provision Name / Provision UUID / App Id",
+                "Team",
+                "Type / Due",
+                "Devices",
+            ], []);
+            function pushProvision(prov) {
+                table.push(["", "", "", ""]);
+                table.push([
+                    (0, helpers_1.quoteString)(prov.Name),
+                    prov.TeamName,
+                    prov.Type,
+                    formatTotalDeviceCount(prov),
+                ]);
+                table.push([
+                    prov.UUID,
+                    prov.TeamIdentifier && prov.TeamIdentifier.length > 0
+                        ? "(" + prov.TeamIdentifier[0] + ")"
+                        : "",
+                    formatDate(prov.ExpirationDate),
+                    formatSupportedDeviceCount(prov),
+                ]);
+                table.push([prov.Entitlements["application-identifier"], "", "", ""]);
+            }
+            match.eligible.forEach((prov) => pushProvision(prov));
+            this.$logger.info(table.toString());
+            this.$logger.info();
+            this.$logger.info("There are also " +
+                match.nonEligible.length +
+                " non-eligible provisioning profiles.");
+            this.$logger.info();
+        });
+    }
+    listTeams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const teams = yield this.getDevelopmentTeams();
+            const table = (0, helpers_1.createTable)(["Team Name", "Team ID"], teams.map((team) => [(0, helpers_1.quoteString)(team.name), team.id]));
+            this.$logger.info(table.toString());
+        });
+    }
+    queryProvisioningProfilesAndDevices(projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const certificates = mobileprovision.cert.read();
+            const provisions = mobileprovision.provision.read();
+            const query = {
+                Certificates: certificates.valid,
+                Unique: true,
+                AppId: projectId,
+            };
+            let devices = [];
+            if (this.$options.device) {
+                devices = [this.$options.device];
+            }
+            else {
+                yield this.$devicesService.initialize({
+                    platform: "ios",
+                    skipEmulatorStart: true,
+                });
+                devices = _(this.$devicesService.getDeviceInstances())
+                    .filter((d) => this.$mobileHelper.isiOSPlatform(d.deviceInfo.platform))
+                    .map((d) => d.deviceInfo.identifier)
+                    .toJSON();
+            }
+            const match = mobileprovision.provision.select(provisions, query);
+            return { devices, match };
+        });
+    }
+    getDevelopmentTeams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const teams = {};
+            mobileprovision.provision.read().forEach((provision) => provision.TeamIdentifier &&
+                provision.TeamIdentifier.forEach((id) => {
+                    if (!teams[provision.TeamName]) {
+                        teams[provision.TeamName] = new Set();
+                    }
+                    teams[provision.TeamName].add(id);
+                }));
+            const teamsArray = Object.keys(teams).reduce((arr, name) => {
+                teams[name].forEach((id) => arr.push({ id, name }));
+                return arr;
+            }, []);
+            return teamsArray;
+        });
+    }
+    getTeamIdsWithName(teamName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allTeams = yield this.getDevelopmentTeams();
+            const matchingTeamIds = allTeams
+                .filter((team) => team.name === teamName)
+                .map((team) => team.id);
+            return matchingTeamIds;
+        });
+    }
+}
+exports.IOSProvisionService = IOSProvisionService;
+yok_1.injector.register("iOSProvisionService", IOSProvisionService);

package/lib/services/ios-watch-app-service.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSWatchAppService = void 0;
+const path = require("path");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class IOSWatchAppService {
+    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService) {
+        this.$fs = $fs;
+        this.$pbxprojDomXcode = $pbxprojDomXcode;
+        this.$xcode = $xcode;
+        this.$iOSNativeTargetService = $iOSNativeTargetService;
+    }
+    addWatchAppFromPath({ watchAppFolderPath, projectData, platformData, pbxProjPath, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetUuids = [];
+            const appPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_FOLDER);
+            const extensionPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_EXTENSION_FOLDER);
+            if (!this.$fs.exists(appPath) || !this.$fs.exists(extensionPath)) {
+                return false;
+            }
+            const appFolder = this.$iOSNativeTargetService.getTargetDirectories(appPath)[0];
+            const extensionFolder = this.$iOSNativeTargetService.getTargetDirectories(extensionPath)[0];
+            const project = new this.$xcode.project(pbxProjPath);
+            project.parseSync();
+            const watchApptarget = this.$iOSNativeTargetService.addTargetToProject(appPath, appFolder, constants_1.IOSNativeTargetTypes.watchApp, project, platformData, project.getFirstTarget().uuid);
+            this.configureTarget(appFolder, path.join(appPath, appFolder), `${projectData.projectIdentifiers.ios}.${IOSWatchAppService.WATCH_APP_IDENTIFIER}`, "watchapp.json", watchApptarget, project);
+            targetUuids.push(watchApptarget.uuid);
+            const watchExtensionTarget = this.$iOSNativeTargetService.addTargetToProject(extensionPath, extensionFolder, constants_1.IOSNativeTargetTypes.watchExtension, project, platformData, watchApptarget.uuid);
+            this.configureTarget(extensionFolder, path.join(extensionPath, extensionFolder), `${projectData.projectIdentifiers.ios}.${IOSWatchAppService.WATCH_APP_IDENTIFIER}.${IOSWatchAppService.WACTCH_EXTENSION_IDENTIFIER}`, "extension.json", watchExtensionTarget, project);
+            targetUuids.push(watchExtensionTarget.uuid);
+            this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+            this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, pbxProjPath);
+            return true;
+        });
+    }
+    removeWatchApp({ pbxProjPath }) {
+        const project = new this.$xcode.project(pbxProjPath);
+        project.parseSync();
+        project.removeTargetsByProductType(constants_1.IOSNativeTargetProductTypes.watchApp);
+        project.removeTargetsByProductType(constants_1.IOSNativeTargetProductTypes.watchExtension);
+        this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+    }
+    hasWatchApp(platformData, projectData) {
+        const watchAppPath = path.join(projectData.getAppResourcesDirectoryPath(), platformData.normalizedPlatformName, constants_1.IOS_WATCHAPP_FOLDER);
+        return this.$fs.exists(watchAppPath);
+    }
+    configureTarget(targetName, targetPath, identifier, configurationFileName, target, project) {
+        const targetConfigurationJsonPath = path.join(targetPath, configurationFileName);
+        const identifierParts = identifier.split(".");
+        identifierParts.pop();
+        const wkAppBundleIdentifier = identifierParts.join(".");
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+            { name: "PRODUCT_BUNDLE_IDENTIFIER", value: identifier },
+            { name: "SDKROOT", value: "watchos" },
+            { name: "TARGETED_DEVICE_FAMILY", value: constants_1.IOSDeviceTargets.watchos },
+            { name: "WATCHOS_DEPLOYMENT_TARGET", value: 5.2 },
+            { name: "WK_APP_BUNDLE_IDENTIFIER", value: wkAppBundleIdentifier },
+        ], targetName, project);
+        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(targetConfigurationJsonPath, target.uuid, targetName, project);
+        project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
+    }
+}
+IOSWatchAppService.WATCH_APP_IDENTIFIER = "watchkitapp";
+IOSWatchAppService.WACTCH_EXTENSION_IDENTIFIER = "watchkitextension";
+exports.IOSWatchAppService = IOSWatchAppService;
+yok_1.injector.register("iOSWatchAppService", IOSWatchAppService);

package/lib/services/ip-service.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPService = void 0;
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+class IPService {
+    constructor($httpClient, $logger) {
+        this.$httpClient = $httpClient;
+        this.$logger = $logger;
+    }
+    getCurrentIPv4Address() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ipAddress = (yield this.getIPAddressFromServiceReturningJSONWithIPProperty("https://api.myip.com")) ||
+                (yield this.getIPAddressFromIpifyOrgAPI()) ||
+                null;
+            return ipAddress;
+        });
+    }
+    getIPAddressFromServiceReturningJSONWithIPProperty(apiEndpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ipAddress = null;
+            try {
+                const response = yield this.$httpClient.httpRequest({
+                    method: "GET",
+                    url: apiEndpoint,
+                    timeout: IPService.GET_IP_TIMEOUT,
+                });
+                this.$logger.trace(`${apiEndpoint} returns ${response.body}`);
+                const jsonData = JSON.parse(response.body);
+                ipAddress = jsonData.ip;
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to get information about current IP Address from ${apiEndpoint} Error is:`, err);
+            }
+            return ipAddress;
+        });
+    }
+    getIPAddressFromIpifyOrgAPI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ipifyOrgAPIEndpoint = "https://api.ipify.org";
+            let ipAddress = null;
+            try {
+                const response = yield this.$httpClient.httpRequest({
+                    method: "GET",
+                    url: ipifyOrgAPIEndpoint,
+                    timeout: IPService.GET_IP_TIMEOUT,
+                });
+                this.$logger.trace(`${ipifyOrgAPIEndpoint} returns ${response.body}`);
+                ipAddress = (response.body || "").toString();
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to get information about current IP Address from ${ipifyOrgAPIEndpoint} Error is:`, err);
+            }
+            return ipAddress;
+        });
+    }
+}
+IPService.GET_IP_TIMEOUT = 1000;
+__decorate([
+    (0, decorators_1.cache)()
+], IPService.prototype, "getCurrentIPv4Address", null);
+exports.IPService = IPService;
+yok_1.injector.register("ipService", IPService);

package/lib/services/itmstransporter-service.js

@@ -0,0 +1,216 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITMSTransporterService = void 0;
+const path = require("path");
+const constants_1 = require("../constants");
+const helpers_1 = require("../common/helpers");
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+class ITMSTransporterService {
+    constructor($applePortalApplicationService, $childProcess, $errors, $fs, $injector, $logger, $plistParser, $xcodeSelectService, $tempService) {
+        this.$applePortalApplicationService = $applePortalApplicationService;
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$injector = $injector;
+        this.$logger = $logger;
+        this.$plistParser = $plistParser;
+        this.$xcodeSelectService = $xcodeSelectService;
+        this.$tempService = $tempService;
+    }
+    get $projectData() {
+        return this.$injector.resolve("projectData");
+    }
+    validate(appSpecificPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itmsTransporterPath = yield this.getITMSTransporterPath();
+            const version = yield this.$xcodeSelectService.getXcodeVersion();
+            if (+version.major < 14) {
+                if (!this.$fs.exists(itmsTransporterPath)) {
+                    this.$errors.fail("iTMS Transporter not found on this machine - make sure your Xcode installation is not damaged.");
+                }
+            }
+            else {
+                const altoolPath = yield this.getAltoolPath();
+                if (!this.$fs.exists(altoolPath)) {
+                    this.$errors.fail("altool not found on this machine - make sure your Xcode installation is not damaged.");
+                }
+                if (!appSpecificPassword) {
+                    this.$errors.fail("An app-specific password is required from xCode versions 14 and above, Use the --appleApplicationSpecificPassword to supply it.");
+                }
+            }
+        });
+    }
+    upload(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const version = yield this.$xcodeSelectService.getXcodeVersion();
+            if (+version.major < 14) {
+                yield this.upload_iTMSTransporter(data);
+            }
+            else {
+                yield this.upload_altool(data);
+            }
+        });
+    }
+    upload_iTMSTransporter(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itmsTransporterPath = yield this.getITMSTransporterPath();
+            const ipaFileName = "app.ipa";
+            const itmsDirectory = yield this.$tempService.mkdirSync("itms-");
+            const innerDirectory = path.join(itmsDirectory, "mybundle.itmsp");
+            const ipaFileLocation = path.join(innerDirectory, ipaFileName);
+            const loggingLevel = data.verboseLogging
+                ? constants_1.ITMSConstants.VerboseLoggingLevels.Verbose
+                : constants_1.ITMSConstants.VerboseLoggingLevels.Informational;
+            const bundleId = yield this.getBundleIdentifier(data);
+            const application = yield this.$applePortalApplicationService.getApplicationByBundleId(data.user, bundleId);
+            this.$fs.createDirectory(innerDirectory);
+            this.$fs.copyFile(data.ipaFilePath, ipaFileLocation);
+            const ipaFileHash = yield this.$fs.getFileShasum(ipaFileLocation, {
+                algorithm: "md5",
+            });
+            const ipaFileSize = this.$fs.getFileSize(ipaFileLocation);
+            const metadata = this.getITMSMetadataXml(application.adamId, ipaFileName, ipaFileHash, ipaFileSize);
+            this.$fs.writeFile(path.join(innerDirectory, constants_1.ITMSConstants.ApplicationMetadataFile), metadata);
+            const password = data.user.isTwoFactorAuthenticationEnabled
+                ? data.applicationSpecificPassword
+                : data.credentials.password;
+            yield this.$childProcess.spawnFromEvent(itmsTransporterPath, [
+                "-m",
+                "upload",
+                "-f",
+                itmsDirectory,
+                "-u",
+                (0, helpers_1.quoteString)(data.credentials.username),
+                "-p",
+                (0, helpers_1.quoteString)(password),
+                "-v",
+                loggingLevel,
+            ], "close", { stdio: "inherit" });
+        });
+    }
+    upload_altool(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const altoolPath = yield this.getAltoolPath();
+            const ipaFileName = "app.ipa";
+            const itmsDirectory = yield this.$tempService.mkdirSync("itms-");
+            const innerDirectory = path.join(itmsDirectory, "mybundle.itmsp");
+            const ipaFileLocation = path.join(innerDirectory, ipaFileName);
+            this.$fs.createDirectory(innerDirectory);
+            this.$fs.copyFile(data.ipaFilePath, ipaFileLocation);
+            const password = data.applicationSpecificPassword;
+            const args = [
+                "--upload-app",
+                "-t",
+                "ios",
+                "-f",
+                ipaFileLocation,
+                "-u",
+                data.credentials.username,
+                "-p",
+                password,
+                "-k 100000",
+            ];
+            if (data.teamId) {
+                args.push("--asc-provider");
+                args.push(data.teamId);
+            }
+            if (data.verboseLogging) {
+                args.push("--verbose");
+            }
+            yield this.$childProcess.spawnFromEvent(altoolPath, args, "close", {
+                stdio: "inherit",
+            });
+        });
+    }
+    getBundleIdentifier(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { shouldExtractIpa, ipaFilePath } = data;
+            if (shouldExtractIpa) {
+                if (!this.$fs.exists(ipaFilePath) ||
+                    path.extname(ipaFilePath) !== ".ipa") {
+                    this.$errors.fail(`Cannot use specified ipa file ${ipaFilePath}. File either does not exist or is not an ipa file.`);
+                }
+                this.$logger.trace("--ipa set - extracting .ipa file to get app's bundle identifier");
+                const destinationDir = yield this.$tempService.mkdirSync("ipa-");
+                yield this.$fs.unzip(ipaFilePath, destinationDir);
+                const payloadDir = path.join(destinationDir, "Payload");
+                let allFiles = this.$fs.readDirectory(payloadDir);
+                this.$logger.trace("ITMSTransporter .ipa Payload files:");
+                allFiles.forEach((f) => this.$logger.trace(" - " + f));
+                allFiles = allFiles.filter((f) => path.extname(f).toLowerCase() === ".app");
+                if (allFiles.length > 1) {
+                    this.$errors.fail("In the .ipa the ITMSTransporter is uploading there is more than one .app file. We don't know which one to upload.");
+                }
+                else if (allFiles.length <= 0) {
+                    this.$errors.fail("In the .ipa the ITMSTransporter is uploading there must be at least one .app file.");
+                }
+                const appFile = path.join(payloadDir, allFiles[0]);
+                const plistObject = yield this.$plistParser.parseFile(path.join(appFile, constants_1.INFO_PLIST_FILE_NAME));
+                const bundleId = plistObject && plistObject.CFBundleIdentifier;
+                if (!bundleId) {
+                    this.$errors.fail(`Unable to determine bundle identifier from ${ipaFilePath}.`);
+                }
+                this.$logger.trace(`bundle identifier determined to be ${bundleId}`);
+                return bundleId;
+            }
+            return this.$projectData.projectIdentifiers.ios;
+        });
+    }
+    getAltoolPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const xcodePath = yield this.$xcodeSelectService.getContentsDirectoryPath();
+            let itmsTransporterPath = path.join(xcodePath, "..", "Contents", "Developer", "usr", "bin", constants_1.ITMSConstants.altoolExecutableName);
+            return itmsTransporterPath;
+        });
+    }
+    getITMSTransporterPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const xcodePath = yield this.$xcodeSelectService.getContentsDirectoryPath();
+            let itmsTransporterPath = path.join(xcodePath, "..", "Contents", "SharedFrameworks", "ContentDeliveryServices.framework", "Versions", "A", "itms", "bin", constants_1.ITMSConstants.iTMSExecutableName);
+            const xcodeVersionData = yield this.$xcodeSelectService.getXcodeVersion();
+            if (+xcodeVersionData.major < 11) {
+                const loaderAppContentsPath = path.join(xcodePath, "Applications", "Application Loader.app", "Contents");
+                itmsTransporterPath = path.join(loaderAppContentsPath, constants_1.ITMSConstants.iTMSDirectoryName, "bin", constants_1.ITMSConstants.iTMSExecutableName);
+            }
+            return itmsTransporterPath;
+        });
+    }
+    getITMSMetadataXml(appleId, ipaFileName, ipaFileHash, ipaFileSize) {
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<package version="software4.7" xmlns="http://apple.com/itunes/importer">
+    <software_assets apple_id="${appleId}">
+        <asset type="bundle">
+            <data_file>
+                <file_name>${ipaFileName}</file_name>
+                <checksum type="md5">${ipaFileHash}</checksum>
+                <size>${ipaFileSize}</size>
+            </data_file>
+        </asset>
+    </software_assets>
+</package>`;
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], ITMSTransporterService.prototype, "getAltoolPath", null);
+__decorate([
+    (0, decorators_1.cache)()
+], ITMSTransporterService.prototype, "getITMSTransporterPath", null);
+exports.ITMSTransporterService = ITMSTransporterService;
+yok_1.injector.register("itmsTransporterService", ITMSTransporterService);

package/lib/services/karma-execution.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const package_path_helper_1 = require("../helpers/package-path-helper");
+process.on("message", (data) => {
+    if (data.karmaConfig) {
+        const pathToKarma = (0, package_path_helper_1.resolvePackagePath)("karma", {
+            paths: [data.karmaConfig.projectDir],
+        });
+        const KarmaServer = require(path.join(pathToKarma, "lib/server"));
+        const karma = new KarmaServer(data.karmaConfig, (exitCode) => {
+            process.exit(exitCode);
+        });
+        karma.start();
+    }
+});

package/lib/services/livesync/android-device-livesync-service-base.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidDeviceLiveSyncServiceBase = void 0;
+const device_livesync_service_base_1 = require("./device-livesync-service-base");
+const _ = require("lodash");
+class AndroidDeviceLiveSyncServiceBase extends device_livesync_service_base_1.DeviceLiveSyncServiceBase {
+    constructor($injector, $platformsDataService, $filesHashService, $logger, device) {
+        super($platformsDataService, device);
+        this.$injector = $injector;
+        this.$platformsDataService = $platformsDataService;
+        this.$filesHashService = $filesHashService;
+        this.$logger = $logger;
+        this.device = device;
+    }
+    transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceDescriptor, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceHashService = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier);
+            const currentHashes = yield deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
+            const transferredFiles = yield this.transferFilesCore(deviceAppData, localToDevicePaths, projectFilesPath, currentHashes, options);
+            yield this.device.fileSystem.updateHashesOnDevice(currentHashes, deviceAppData.appIdentifier);
+            return transferredFiles;
+        });
+    }
+    transferFilesCore(deviceAppData, localToDevicePaths, projectFilesPath, currentHashes, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options.force && options.isFullSync) {
+                const hashFileDevicePath = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier).hashFileDevicePath;
+                yield this.device.fileSystem.deleteFile(hashFileDevicePath, deviceAppData.appIdentifier);
+                this.$logger.trace("Before transfer directory on device ", localToDevicePaths);
+                yield this.transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath);
+                return localToDevicePaths;
+            }
+            const localToDevicePathsToTransfer = yield this.getLocalToDevicePathsToTransfer(deviceAppData, localToDevicePaths, currentHashes, options);
+            this.$logger.trace("Files to transfer: ", localToDevicePathsToTransfer);
+            yield this.transferFilesOnDevice(deviceAppData, localToDevicePathsToTransfer);
+            return localToDevicePathsToTransfer;
+        });
+    }
+    getLocalToDevicePathsToTransfer(deviceAppData, localToDevicePaths, currentHashes, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options.force || !options.isFullSync) {
+                return localToDevicePaths;
+            }
+            const changedLocalToDevicePaths = yield this.getChangedLocalToDevicePaths(deviceAppData.appIdentifier, localToDevicePaths, currentHashes);
+            return changedLocalToDevicePaths;
+        });
+    }
+    getChangedLocalToDevicePaths(appIdentifier, localToDevicePaths, currentHashes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceHashService = this.device.fileSystem.getDeviceHashService(appIdentifier);
+            const oldHashes = (yield deviceHashService.getShasumsFromDevice()) || {};
+            const changedHashes = deviceHashService.getChangedShasums(oldHashes, currentHashes);
+            const changedFiles = _.keys(changedHashes);
+            const changedLocalToDevicePaths = localToDevicePaths.filter((localToDevicePathData) => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
+            return changedLocalToDevicePaths;
+        });
+    }
+}
+exports.AndroidDeviceLiveSyncServiceBase = AndroidDeviceLiveSyncServiceBase;