@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,69 @@
+"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.DeviceLiveSyncServiceBase = void 0;
+const decorators_1 = require("../../common/decorators");
+const path = require("path");
+const _ = require("lodash");
+const decorators_2 = require("../../common/decorators");
+class DeviceLiveSyncServiceBase {
+    constructor(platformsDataService, device) {
+        this.platformsDataService = platformsDataService;
+        this.device = device;
+    }
+    canExecuteFastSync(liveSyncResult, filePath, projectData, platform) {
+        const fastSyncFileExtensions = this.getFastLiveSyncFileExtensions(platform, projectData);
+        return (liveSyncResult.useHotModuleReload ||
+            _.includes(fastSyncFileExtensions, path.extname(filePath)));
+    }
+    canExecuteFastSyncForPaths(liveSyncResult, localToDevicePaths, projectData, platform) {
+        return !_.some(localToDevicePaths, (localToDevicePath) => !this.canExecuteFastSync(liveSyncResult, localToDevicePath.getLocalPath(), projectData, this.device.deviceInfo.platform));
+    }
+    getFastLiveSyncFileExtensions(platform, projectData) {
+        const platformData = this.platformsDataService.getPlatformData(platform, projectData);
+        const fastSyncFileExtensions = DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS.concat(platformData.fastLivesyncFileExtensions);
+        return fastSyncFileExtensions;
+    }
+    transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceDescriptor, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transferredFiles = [];
+            if (options.isFullSync) {
+                transferredFiles = yield this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
+            }
+            else {
+                transferredFiles = yield this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
+            }
+            return transferredFiles;
+        });
+    }
+    finalizeSync(liveSyncInfo, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                didRefresh: true,
+                operationId: "",
+            };
+        });
+    }
+}
+DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml", ".html"];
+__decorate([
+    (0, decorators_1.cache)()
+], DeviceLiveSyncServiceBase.prototype, "getFastLiveSyncFileExtensions", null);
+__decorate([
+    (0, decorators_2.performanceLog)()
+], DeviceLiveSyncServiceBase.prototype, "transferFiles", null);
+exports.DeviceLiveSyncServiceBase = DeviceLiveSyncServiceBase;

package/lib/services/livesync/ios-device-livesync-service.js

@@ -0,0 +1,218 @@
+"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.IOSDeviceLiveSyncService = void 0;
+const constants = require("../../constants");
+const minimatch_1 = require("minimatch");
+const _ = require("lodash");
+const device_livesync_service_base_1 = require("./device-livesync-service-base");
+const decorators_1 = require("../../common/decorators");
+const semver = require("semver");
+let currentPageReloadId = 0;
+class IOSDeviceLiveSyncService extends device_livesync_service_base_1.DeviceLiveSyncServiceBase {
+    constructor($logger, $iOSSocketRequestExecutor, $devicePlatformsConstants, $lockService, platformsDataService, $platformCommandHelper, device) {
+        super(platformsDataService, device);
+        this.$logger = $logger;
+        this.$iOSSocketRequestExecutor = $iOSSocketRequestExecutor;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$lockService = $lockService;
+        this.platformsDataService = platformsDataService;
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.device = device;
+    }
+    canRefreshWithNotification(projectData, liveSyncInfo) {
+        if (liveSyncInfo && liveSyncInfo.forceRefreshWithSocket) {
+            return false;
+        }
+        if (this.device.isEmulator) {
+            return false;
+        }
+        const currentRuntimeVersion = this.$platformCommandHelper.getCurrentPlatformVersion(this.$devicePlatformsConstants.iOS, projectData);
+        const canRefresh = semver.gte(semver.coerce(currentRuntimeVersion), IOSDeviceLiveSyncService.MIN_RUNTIME_VERSION_WITH_REFRESH_NOTIFICATION);
+        return canRefresh;
+    }
+    setupSocketIfNeeded(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket) {
+                return true;
+            }
+            const appId = projectData.projectIdentifiers.ios;
+            try {
+                const ensureAppStarted = true;
+                this.socket = yield this.device.getDebugSocket(appId, projectData.projectName, projectData.projectDir, ensureAppStarted);
+            }
+            catch (err) {
+                this.$logger.trace(`Error while connecting to the debug socket. Error is:`, err);
+            }
+            if (!this.socket) {
+                return false;
+            }
+            this.attachEventHandlers();
+            return true;
+        });
+    }
+    removeFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.device.fileSystem.deleteFile(localToDevicePathData.getDevicePath(), deviceAppData.appIdentifier)));
+        });
+    }
+    shouldRestart(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let shouldRestart = false;
+            const deviceAppData = liveSyncInfo.deviceAppData;
+            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+            if (liveSyncInfo.isFullSync || liveSyncInfo.waitForDebugger) {
+                shouldRestart = true;
+            }
+            else {
+                const canExecuteFastSync = this.canExecuteFastSyncForPaths(liveSyncInfo, localToDevicePaths, projectData, deviceAppData.platform);
+                const isRefreshConnectionSetup = this.canRefreshWithNotification(projectData, liveSyncInfo) ||
+                    (!this.device.isOnlyWiFiConnected && this.socket);
+                if (!canExecuteFastSync || !isRefreshConnectionSetup) {
+                    shouldRestart = true;
+                }
+            }
+            return shouldRestart;
+        });
+    }
+    tryRefreshApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didRefresh = true;
+            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+            let scriptRelatedFiles = [];
+            constants.LIVESYNC_EXCLUDED_FILE_PATTERNS.forEach((pattern) => (scriptRelatedFiles = _.concat(scriptRelatedFiles, localToDevicePaths.filter((file) => (0, minimatch_1.minimatch)(file.getDevicePath(), pattern, { nocase: true })))));
+            const scriptFiles = _.filter(localToDevicePaths, (localToDevicePath) => _.endsWith(localToDevicePath.getDevicePath(), ".js"));
+            const otherFiles = _.difference(localToDevicePaths, _.concat(scriptFiles, scriptRelatedFiles));
+            try {
+                if (otherFiles.length) {
+                    didRefresh = yield this.refreshApplicationCore(projectData, liveSyncInfo);
+                }
+            }
+            catch (e) {
+                didRefresh = false;
+            }
+            return didRefresh;
+        });
+    }
+    refreshApplicationCore(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didRefresh = true;
+            if (this.canRefreshWithNotification(projectData, liveSyncInfo)) {
+                didRefresh = yield this.refreshWithNotification(projectData);
+            }
+            else {
+                if (yield this.setupSocketIfNeeded(projectData)) {
+                    yield this.reloadPage();
+                }
+                else {
+                    didRefresh = false;
+                }
+            }
+            return didRefresh;
+        });
+    }
+    refreshWithNotification(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didRefresh = false;
+            yield this.$lockService.executeActionWithLock(() => __awaiter(this, void 0, void 0, function* () {
+                didRefresh = yield this.$iOSSocketRequestExecutor.executeRefreshRequest(this.device, 5, projectData.projectIdentifiers.ios);
+            }), `ios-device-livesync-${this.device.deviceInfo.identifier}-${projectData.projectIdentifiers.ios}.lock`);
+            return didRefresh;
+        });
+    }
+    restartApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.applicationManager.restartApplication({
+                appId: liveSyncInfo.deviceAppData.appIdentifier,
+                projectName: projectData.projectName,
+                waitForDebugger: liveSyncInfo.waitForDebugger,
+                projectDir: projectData.projectDir,
+            });
+            if (liveSyncInfo.useHotModuleReload) {
+                yield this.setupSocketIfNeeded(projectData);
+            }
+        });
+    }
+    reloadPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = JSON.stringify({
+                method: "Page.reload",
+                params: {
+                    ignoreCache: false,
+                },
+                id: ++currentPageReloadId,
+            });
+            yield this.sendMessage(message);
+        });
+    }
+    attachEventHandlers() {
+        this.socket.on("close", (hadError) => {
+            this.$logger.trace(`Socket closed, hadError is ${hadError}.`);
+            this.socket = null;
+        });
+        this.socket.on("error", (error) => {
+            this.$logger.trace(`Socket error received: ${error}`);
+        });
+        this.socket.on("data", (data) => {
+            this.$logger.trace(`Socket sent data: ${data.toString()}`);
+        });
+    }
+    sendMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield new Promise((resolve, reject) => {
+                    let isResolved = false;
+                    const length = Buffer.byteLength(message, "utf16le");
+                    const payload = Buffer.allocUnsafe(length + 4);
+                    payload.writeInt32BE(length, 0);
+                    payload.write(message, 4, length, "utf16le");
+                    const errorCallback = (error) => {
+                        if (!isResolved) {
+                            isResolved = true;
+                            reject(error);
+                        }
+                    };
+                    this.socket.once("error", errorCallback);
+                    this.socket.write(payload, "utf16le", () => {
+                        this.socket.removeListener("error", errorCallback);
+                        if (!isResolved) {
+                            isResolved = true;
+                            resolve();
+                        }
+                    });
+                });
+            }
+            catch (error) {
+                this.$logger.trace("Error while sending message:", error);
+                yield this.destroySocket();
+            }
+        });
+    }
+    destroySocket() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket) {
+                yield this.device.destroyAllSockets();
+                this.socket = null;
+            }
+        });
+    }
+}
+IOSDeviceLiveSyncService.MIN_RUNTIME_VERSION_WITH_REFRESH_NOTIFICATION = "6.1.0";
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSDeviceLiveSyncService.prototype, "removeFiles", null);
+exports.IOSDeviceLiveSyncService = IOSDeviceLiveSyncService;

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

@@ -0,0 +1,95 @@
+"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.IOSLiveSyncService = void 0;
+const path = require("path");
+const ios_device_livesync_service_1 = require("./ios-device-livesync-service");
+const platform_livesync_service_base_1 = require("./platform-livesync-service-base");
+const constants_1 = require("../../constants");
+const decorators_1 = require("../../common/decorators");
+const yok_1 = require("../../common/yok");
+class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSyncServiceBase {
+    constructor($fs, $platformsDataService, $projectFilesManager, $injector, $tempService, $devicePathProvider, $logger) {
+        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider);
+        this.$fs = $fs;
+        this.$platformsDataService = $platformsDataService;
+        this.$projectFilesManager = $projectFilesManager;
+        this.$injector = $injector;
+        this.$tempService = $tempService;
+    }
+    fullSync(syncInfo) {
+        const _super = Object.create(null, {
+            fullSync: { get: () => super.fullSync }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = syncInfo.device;
+            if (device.isEmulator) {
+                return _super.fullSync.call(this, syncInfo);
+            }
+            const projectData = syncInfo.projectData;
+            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+            const deviceAppData = yield this.getAppData(syncInfo);
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+            const tempZip = yield this.$tempService.path({
+                prefix: "sync",
+                suffix: ".zip",
+            });
+            this.$logger.trace("Creating zip file: " + tempZip);
+            const filesToTransfer = this.$fs.enumerateFilesInDirectorySync(projectFilesPath);
+            yield this.$fs.zipFiles(tempZip, filesToTransfer, (res) => {
+                return path.join(constants_1.APP_FOLDER_NAME, path.relative(projectFilesPath, res));
+            });
+            yield device.fileSystem.transferFiles(deviceAppData, [
+                {
+                    getLocalPath: () => tempZip,
+                    getDevicePath: () => deviceAppData.deviceSyncZipPath,
+                    getRelativeToProjectBasePath: () => "../sync.zip",
+                    deviceProjectRootPath: yield deviceAppData.getDeviceProjectRootPath(),
+                },
+            ]);
+            yield deviceAppData.device.applicationManager.setTransferredAppFiles(filesToTransfer);
+            return {
+                deviceAppData,
+                isFullSync: true,
+                modifiedFilesData: [],
+                useHotModuleReload: syncInfo.useHotModuleReload,
+            };
+        });
+    }
+    syncAfterInstall(device, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!device.isEmulator) {
+                yield this.fullSync({
+                    projectData: liveSyncInfo.projectData,
+                    device,
+                    liveSyncDeviceData: liveSyncInfo.liveSyncDeviceData,
+                    watch: true,
+                    useHotModuleReload: liveSyncInfo.useHotModuleReload,
+                });
+            }
+        });
+    }
+    _getDeviceLiveSyncService(device, data) {
+        const service = this.$injector.resolve(ios_device_livesync_service_1.IOSDeviceLiveSyncService, { device, data });
+        return service;
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSLiveSyncService.prototype, "fullSync", null);
+exports.IOSLiveSyncService = IOSLiveSyncService;
+yok_1.injector.register("iOSLiveSyncService", IOSLiveSyncService);

package/lib/services/livesync/livesync-socket.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveSyncSocket = void 0;
+const net = require("net");
+const yok_1 = require("../../common/yok");
+class LiveSyncSocket extends net.Socket {
+    writeAsync(data) {
+        return new Promise((resolve, reject) => {
+            const result = this.write(data, () => resolve(result));
+        });
+    }
+}
+exports.LiveSyncSocket = LiveSyncSocket;
+yok_1.injector.register("LiveSyncSocket", LiveSyncSocket, false);

package/lib/services/livesync/platform-livesync-service-base.js

@@ -0,0 +1,180 @@
+"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.PlatformLiveSyncServiceBase = void 0;
+const path = require("path");
+const util = require("util");
+const _ = require("lodash");
+const constants_1 = require("../../constants");
+const helpers_1 = require("../../common/helpers");
+const decorators_1 = require("../../common/decorators");
+const color_1 = require("../../color");
+class PlatformLiveSyncServiceBase {
+    constructor($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$platformsDataService = $platformsDataService;
+        this.$projectFilesManager = $projectFilesManager;
+        this.$devicePathProvider = $devicePathProvider;
+        this._deviceLiveSyncServicesCache = {};
+    }
+    getDeviceLiveSyncService(device, projectData) {
+        const platform = device.deviceInfo.platform.toLowerCase();
+        const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+        const frameworkVersion = platformData.platformProjectService.getFrameworkVersion(projectData);
+        const key = (0, helpers_1.getHash)(`${device.deviceInfo.identifier}${projectData.projectIdentifiers[platform]}${projectData.projectDir}${frameworkVersion}`);
+        if (!this._deviceLiveSyncServicesCache[key]) {
+            this._deviceLiveSyncServicesCache[key] = this._getDeviceLiveSyncService(device, projectData, frameworkVersion);
+        }
+        return this._deviceLiveSyncServicesCache[key];
+    }
+    shouldRestart(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+            const shouldRestart = yield deviceLiveSyncService.shouldRestart(projectData, liveSyncInfo);
+            return shouldRestart;
+        });
+    }
+    syncAfterInstall(device, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    restartApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+            this.$logger.info(`Restarting application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
+            yield deviceLiveSyncService.restartApplication(projectData, liveSyncInfo);
+        });
+    }
+    tryRefreshApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didRefresh = true;
+            if (liveSyncInfo.isFullSync || liveSyncInfo.modifiedFilesData.length) {
+                const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+                this.$logger.info(`Refreshing application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
+                didRefresh = yield deviceLiveSyncService.tryRefreshApplication(projectData, liveSyncInfo);
+            }
+            return didRefresh;
+        });
+    }
+    fullSync(syncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = syncInfo.projectData;
+            const device = syncInfo.device;
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(device, syncInfo.projectData);
+            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+            const deviceAppData = yield this.getAppData(syncInfo);
+            if (deviceLiveSyncService.beforeLiveSyncAction) {
+                yield deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
+            }
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+            const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, null, []);
+            const modifiedFilesData = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, syncInfo.liveSyncDeviceData, { isFullSync: true, force: syncInfo.force });
+            return {
+                modifiedFilesData,
+                isFullSync: true,
+                deviceAppData,
+                useHotModuleReload: syncInfo.useHotModuleReload,
+            };
+        });
+    }
+    liveSyncWatchAction(device, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectData = liveSyncInfo.projectData;
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(device, projectData);
+            const syncInfo = _.merge({ device, watch: true }, liveSyncInfo);
+            const deviceAppData = yield this.getAppData(syncInfo);
+            if (deviceLiveSyncService.beforeLiveSyncAction) {
+                yield deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
+            }
+            let modifiedLocalToDevicePaths = [];
+            if (liveSyncInfo.filesToSync.length) {
+                const filesToSync = liveSyncInfo.filesToSync;
+                const existingFiles = filesToSync.filter((m) => m && this.$fs.exists(m));
+                this.$logger.trace("Will execute livesync for files: ", existingFiles);
+                const skippedFiles = _.difference(filesToSync, existingFiles);
+                if (skippedFiles.length) {
+                    this.$logger.trace("The following files will not be synced as they do not exist:", skippedFiles);
+                }
+                if (existingFiles.length) {
+                    const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+                    const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+                    const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, existingFiles, []);
+                    modifiedLocalToDevicePaths.push(...localToDevicePaths);
+                    modifiedLocalToDevicePaths = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncInfo.liveSyncDeviceData, { isFullSync: false, force: liveSyncInfo.force });
+                }
+            }
+            if (liveSyncInfo.filesToRemove.length) {
+                const filePaths = liveSyncInfo.filesToRemove;
+                const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+                const mappedFiles = _(filePaths)
+                    .filter((filePath) => !!filePath)
+                    .value();
+                const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+                const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, mappedFiles, []);
+                modifiedLocalToDevicePaths.push(...localToDevicePaths);
+                yield deviceLiveSyncService.removeFiles(deviceAppData, localToDevicePaths, projectFilesPath);
+            }
+            return {
+                modifiedFilesData: modifiedLocalToDevicePaths,
+                isFullSync: false,
+                deviceAppData,
+                useHotModuleReload: liveSyncInfo.useHotModuleReload,
+            };
+        });
+    }
+    transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transferredFiles = [];
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(deviceAppData.device, projectData);
+            transferredFiles = yield deviceLiveSyncService.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options);
+            yield deviceAppData.device.applicationManager.setTransferredAppFiles(localToDevicePaths.map((l) => l.getLocalPath()));
+            this.logFilesSyncInformation(transferredFiles, "Successfully transferred %s on device %s.", this.$logger.info, deviceAppData.device.deviceInfo.identifier);
+            return transferredFiles;
+        });
+    }
+    getAppData(syncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = syncInfo.device.deviceInfo.platform.toLowerCase();
+            const appIdentifier = syncInfo.projectData.projectIdentifiers[platform];
+            const deviceProjectRootOptions = _.assign({ appIdentifier }, syncInfo);
+            return {
+                appIdentifier,
+                device: syncInfo.device,
+                platform: syncInfo.device.deviceInfo.platform,
+                getDeviceProjectRootPath: () => this.$devicePathProvider.getDeviceProjectRootPath(syncInfo.device, deviceProjectRootOptions),
+                deviceSyncZipPath: this.$devicePathProvider.getDeviceSyncZipPath(syncInfo.device),
+                connectTimeout: syncInfo.connectTimeout,
+                projectDir: syncInfo.projectData.projectDir,
+            };
+        });
+    }
+    logFilesSyncInformation(localToDevicePaths, message, action, deviceIdentifier) {
+        if (localToDevicePaths && localToDevicePaths.length < 10) {
+            _.each(localToDevicePaths, (file) => {
+                action.call(this.$logger, util.format(message, color_1.color.yellow(path.basename(file.getLocalPath()))), deviceIdentifier);
+            });
+        }
+        else {
+            action.call(this.$logger, util.format(message, "all files", deviceIdentifier));
+        }
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], PlatformLiveSyncServiceBase.prototype, "liveSyncWatchAction", null);
+exports.PlatformLiveSyncServiceBase = PlatformLiveSyncServiceBase;

package/lib/services/livesync-process-data-service.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveSyncProcessDataService = void 0;
+const yok_1 = require("../common/yok");
+const _ = require("lodash");
+class LiveSyncProcessDataService {
+    constructor() {
+        this.processes = {};
+    }
+    persistData(projectDir, deviceDescriptors, platforms) {
+        this.processes[projectDir] =
+            this.processes[projectDir] || Object.create(null);
+        this.processes[projectDir].actionsChain =
+            this.processes[projectDir].actionsChain || Promise.resolve();
+        this.processes[projectDir].currentSyncAction = this.processes[projectDir].actionsChain;
+        this.processes[projectDir].isStopped = false;
+        this.processes[projectDir].platforms = platforms;
+        const currentDeviceDescriptors = this.getDeviceDescriptors(projectDir);
+        this.processes[projectDir].deviceDescriptors = _.uniqBy(currentDeviceDescriptors.concat(deviceDescriptors), "identifier");
+    }
+    getPersistedData(projectDir) {
+        return this.processes[projectDir];
+    }
+    getDeviceDescriptors(projectDir) {
+        const liveSyncProcessesInfo = this.processes[projectDir] || {};
+        const currentDescriptors = liveSyncProcessesInfo.deviceDescriptors;
+        return currentDescriptors || [];
+    }
+    hasDeviceDescriptors(projectDir) {
+        const deviceDescriptors = this.getDeviceDescriptors(projectDir);
+        return !!deviceDescriptors.length;
+    }
+    getAllPersistedData() {
+        return this.processes;
+    }
+    getPlatforms(projectDir) {
+        const liveSyncProcessesInfo = this.processes[projectDir] || {};
+        const currentPlatforms = liveSyncProcessesInfo.platforms;
+        return currentPlatforms || [];
+    }
+}
+exports.LiveSyncProcessDataService = LiveSyncProcessDataService;
+yok_1.injector.register("liveSyncProcessDataService", LiveSyncProcessDataService);