@akylas/nativescript-cli 8.7.2 → 8.8.3

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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.AndroidDeviceLiveSyncService = void 0;
 const android_device_livesync_service_base_1 = require("./android-device-livesync-service-base");
@@ -34,170 +25,150 @@ class AndroidDeviceLiveSyncService extends android_device_livesync_service_base_
         this.platformsDataService = platformsDataService;
         this.device = device;
     }
-    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
-        });
+    async transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        await this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
     }
-    transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
-        });
+    async transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
+        await this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
     }
-    restartApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devicePathRoot = util.format(constants_2.ANDROID_DEVICE_APP_ROOT_TEMPLATE, liveSyncInfo.deviceAppData.appIdentifier);
-            const devicePath = this.$mobileHelper.buildDevicePath(devicePathRoot, "code_cache", "secondary_dexes", "proxyThumb");
-            yield this.device.adb.executeShellCommand(["rm", "-rf", devicePath]);
-            yield this.device.applicationManager.restartApplication({
-                appId: liveSyncInfo.deviceAppData.appIdentifier,
-                projectName: projectData.projectName,
-                waitForDebugger: liveSyncInfo.waitForDebugger,
-                projectDir: projectData.projectDir,
-            });
+    async restartApplication(projectData, liveSyncInfo) {
+        const devicePathRoot = util.format(constants_2.ANDROID_DEVICE_APP_ROOT_TEMPLATE, liveSyncInfo.deviceAppData.appIdentifier);
+        const devicePath = this.$mobileHelper.buildDevicePath(devicePathRoot, "code_cache", "secondary_dexes", "proxyThumb");
+        await this.device.adb.executeShellCommand(["rm", "-rf", devicePath]);
+        await this.device.applicationManager.restartApplication({
+            appId: liveSyncInfo.deviceAppData.appIdentifier,
+            projectName: projectData.projectName,
+            waitForDebugger: liveSyncInfo.waitForDebugger,
+            projectDir: projectData.projectDir,
         });
     }
-    shouldRestart(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let shouldRestart = false;
-            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
-            const canExecuteFastSync = !liveSyncInfo.isFullSync &&
-                !_.some(localToDevicePaths, (localToDevicePath) => !this.canExecuteFastSync(liveSyncInfo, localToDevicePath.getLocalPath(), projectData, this.device.deviceInfo.platform));
-            if (!canExecuteFastSync || liveSyncInfo.waitForDebugger) {
-                shouldRestart = true;
-            }
-            return shouldRestart;
+    async shouldRestart(projectData, liveSyncInfo) {
+        let shouldRestart = false;
+        const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+        const canExecuteFastSync = !liveSyncInfo.isFullSync &&
+            !_.some(localToDevicePaths, (localToDevicePath) => !this.canExecuteFastSync(liveSyncInfo, localToDevicePath.getLocalPath(), projectData, this.device.deviceInfo.platform));
+        if (!canExecuteFastSync || liveSyncInfo.waitForDebugger) {
+            shouldRestart = true;
+        }
+        return shouldRestart;
+    }
+    async tryRefreshApplication(projectData, liveSyncInfo) {
+        let didRefresh = true;
+        const deviceAppData = liveSyncInfo.deviceAppData;
+        const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+        const deviceProjectRootDirname = await this.$devicePathProvider.getDeviceProjectRootPath(liveSyncInfo.deviceAppData.device, {
+            appIdentifier: liveSyncInfo.deviceAppData.appIdentifier,
+            getDirname: true,
         });
+        await this.device.adb.executeShellCommand([
+            "chmod",
+            "777",
+            path.dirname(deviceProjectRootDirname),
+            deviceProjectRootDirname,
+            `${deviceProjectRootDirname}/sync`,
+        ]);
+        didRefresh = await this.reloadApplicationFiles(deviceAppData, localToDevicePaths);
+        return didRefresh;
     }
-    tryRefreshApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let didRefresh = true;
-            const deviceAppData = liveSyncInfo.deviceAppData;
-            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
-            const deviceProjectRootDirname = yield this.$devicePathProvider.getDeviceProjectRootPath(liveSyncInfo.deviceAppData.device, {
-                appIdentifier: liveSyncInfo.deviceAppData.appIdentifier,
-                getDirname: true,
-            });
-            yield this.device.adb.executeShellCommand([
-                "chmod",
-                "777",
-                path.dirname(deviceProjectRootDirname),
-                deviceProjectRootDirname,
-                `${deviceProjectRootDirname}/sync`,
-            ]);
-            didRefresh = yield this.reloadApplicationFiles(deviceAppData, localToDevicePaths);
-            return didRefresh;
+    async cleanLivesyncDirectories(deviceAppData) {
+        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+            appIdentifier: deviceAppData.appIdentifier,
+            getDirname: true,
         });
+        await this.device.adb.executeShellCommand([
+            "rm",
+            "-rf",
+            this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.FULLSYNC_DIR_NAME),
+            this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.SYNC_DIR_NAME),
+            this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.REMOVEDSYNC_DIR_NAME),
+        ]);
     }
-    cleanLivesyncDirectories(deviceAppData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
-                appIdentifier: deviceAppData.appIdentifier,
-                getDirname: true,
-            });
-            yield this.device.adb.executeShellCommand([
-                "rm",
-                "-rf",
-                this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.FULLSYNC_DIR_NAME),
-                this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.SYNC_DIR_NAME),
-                this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.REMOVEDSYNC_DIR_NAME),
-            ]);
+    async beforeLiveSyncAction(deviceAppData) {
+        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+            appIdentifier: deviceAppData.appIdentifier,
+            getDirname: true,
         });
+        const deviceRootDir = path.dirname(deviceRootPath);
+        const deviceRootBasename = path.basename(deviceRootPath);
+        const listResult = await this.device.adb.executeShellCommand([
+            "ls",
+            "-l",
+            deviceRootDir,
+        ]);
+        const regex = new RegExp(`^-.*${deviceRootBasename}$`, "m");
+        const matchingFile = (listResult || "").match(regex);
+        if (matchingFile && matchingFile[0] && _.startsWith(matchingFile[0], "-")) {
+            await this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
+        }
+        await this.cleanLivesyncDirectories(deviceAppData);
     }
-    beforeLiveSyncAction(deviceAppData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+    async reloadApplicationFiles(deviceAppData, localToDevicePaths) {
+        if (!this.port) {
+            this.port = await this.$androidProcessService.forwardFreeTcpToAbstractPort({
+                deviceIdentifier: deviceAppData.device.deviceInfo.identifier,
                 appIdentifier: deviceAppData.appIdentifier,
-                getDirname: true,
+                abstractPort: `localabstract:${deviceAppData.appIdentifier}-livesync`,
             });
-            const deviceRootDir = path.dirname(deviceRootPath);
-            const deviceRootBasename = path.basename(deviceRootPath);
-            const listResult = yield this.device.adb.executeShellCommand([
-                "ls",
-                "-l",
-                deviceRootDir,
-            ]);
-            const regex = new RegExp(`^-.*${deviceRootBasename}$`, "m");
-            const matchingFile = (listResult || "").match(regex);
-            if (matchingFile && matchingFile[0] && _.startsWith(matchingFile[0], "-")) {
-                yield this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
-            }
-            yield this.cleanLivesyncDirectories(deviceAppData);
-        });
+        }
+        if (await this.awaitRuntimeReloadSuccessMessage()) {
+            await this.cleanLivesyncDirectories(deviceAppData);
+        }
+        else {
+            return false;
+        }
+        return true;
     }
-    reloadApplicationFiles(deviceAppData, localToDevicePaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.port) {
-                this.port = yield this.$androidProcessService.forwardFreeTcpToAbstractPort({
-                    deviceIdentifier: deviceAppData.device.deviceInfo.identifier,
-                    appIdentifier: deviceAppData.appIdentifier,
-                    abstractPort: `localabstract:${deviceAppData.appIdentifier}-livesync`,
-                });
-            }
-            if (yield this.awaitRuntimeReloadSuccessMessage()) {
-                yield this.cleanLivesyncDirectories(deviceAppData);
-            }
-            else {
-                return false;
-            }
-            return true;
+    async removeFiles(deviceAppData, localToDevicePaths) {
+        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+            appIdentifier: deviceAppData.appIdentifier,
+            getDirname: true,
         });
+        for (const localToDevicePathData of localToDevicePaths) {
+            const relativeUnixPath = _.trimStart(helpers.fromWindowsRelativePathToUnix(localToDevicePathData.getRelativeToProjectBasePath()), "/");
+            const deviceFilePath = this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.REMOVEDSYNC_DIR_NAME, relativeUnixPath);
+            await this.device.adb.executeShellCommand([
+                "mkdir",
+                "-p",
+                path.dirname(deviceFilePath),
+                " && ",
+                "touch",
+                deviceFilePath,
+            ]);
+        }
+        const deviceHashService = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier);
+        await deviceHashService.removeHashes(localToDevicePaths);
     }
-    removeFiles(deviceAppData, localToDevicePaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
-                appIdentifier: deviceAppData.appIdentifier,
-                getDirname: true,
+    async awaitRuntimeReloadSuccessMessage() {
+        return new Promise((resolve, reject) => {
+            let isResolved = false;
+            const socket = new net.Socket();
+            socket.connect(this.port, process.env.NATIVESCRIPT_LIVESYNC_ADDRESS || "127.0.0.1", () => {
+                socket.write(Buffer.from([0, 0, 0, 1, 1]));
             });
-            for (const localToDevicePathData of localToDevicePaths) {
-                const relativeUnixPath = _.trimStart(helpers.fromWindowsRelativePathToUnix(localToDevicePathData.getRelativeToProjectBasePath()), "/");
-                const deviceFilePath = this.$mobileHelper.buildDevicePath(deviceRootPath, constants_1.LiveSyncPaths.REMOVEDSYNC_DIR_NAME, relativeUnixPath);
-                yield this.device.adb.executeShellCommand([
-                    "mkdir",
-                    "-p",
-                    path.dirname(deviceFilePath),
-                    " && ",
-                    "touch",
-                    deviceFilePath,
-                ]);
-            }
-            const deviceHashService = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier);
-            yield deviceHashService.removeHashes(localToDevicePaths);
-        });
-    }
-    awaitRuntimeReloadSuccessMessage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                let isResolved = false;
-                const socket = new net.Socket();
-                socket.connect(this.port, process.env.NATIVESCRIPT_LIVESYNC_ADDRESS || "127.0.0.1", () => {
-                    socket.write(Buffer.from([0, 0, 0, 1, 1]));
-                });
-                socket.on("data", (data) => {
+            socket.on("data", (data) => {
+                isResolved = true;
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on("error", () => {
+                if (!isResolved) {
+                    isResolved = true;
+                    resolve(false);
+                }
+            });
+            socket.on("close", () => {
+                if (!isResolved) {
                     isResolved = true;
-                    socket.destroy();
-                    resolve(true);
-                });
-                socket.on("error", () => {
-                    if (!isResolved) {
-                        isResolved = true;
-                        resolve(false);
-                    }
-                });
-                socket.on("close", () => {
-                    if (!isResolved) {
-                        isResolved = true;
-                        resolve(false);
-                    }
-                });
+                    resolve(false);
+                }
             });
         });
     }
 }
+exports.AndroidDeviceLiveSyncService = AndroidDeviceLiveSyncService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceLiveSyncService.prototype, "beforeLiveSyncAction", null);
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceLiveSyncService.prototype, "removeFiles", null);
-exports.AndroidDeviceLiveSyncService = AndroidDeviceLiveSyncService;

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

@@ -1,18 +1,8 @@
 "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.AndroidDeviceSocketsLiveSyncService = void 0;
 const android_device_livesync_service_base_1 = require("./android-device-livesync-service-base");
-const constants_1 = require("../../constants");
-const constants_2 = require("../../common/constants");
+const constants_1 = require("../../common/constants");
 const android_livesync_tool_1 = require("./android-livesync-tool");
 const path = require("path");
 const semver = require("semver");
@@ -31,168 +21,146 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
         this.$tempService = $tempService;
         this.livesyncTool = this.$injector.resolve(android_livesync_tool_1.AndroidLivesyncTool);
     }
-    beforeLiveSyncAction(deviceAppData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.livesyncTool.hasConnection()) {
-                try {
-                    const pathToLiveSyncFile = yield this.$tempService.path({
-                        prefix: "livesync",
-                    });
-                    this.$fs.writeFile(pathToLiveSyncFile, "");
-                    yield this.device.fileSystem.putFile(pathToLiveSyncFile, this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
-                    yield this.device.applicationManager.startApplication({
-                        appId: deviceAppData.appIdentifier,
-                        projectName: this.data.projectName,
-                        justLaunch: true,
-                        waitForDebugger: false,
-                        projectDir: deviceAppData.projectDir,
-                    });
-                    yield this.connectLivesyncTool(this.data.projectIdentifiers.android, deviceAppData.connectTimeout);
-                }
-                catch (err) {
-                    yield this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
-                    throw err;
-                }
-            }
-        });
-    }
-    getPathToLiveSyncFileOnDevice(appIdentifier) {
-        return `${constants_2.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
-    }
-    finalizeSync(liveSyncInfo, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async beforeLiveSyncAction(deviceAppData) {
+        if (!this.livesyncTool.hasConnection()) {
             try {
-                const result = yield this.doSync(liveSyncInfo, projectData);
-                if (!semver.gte(this.livesyncTool.protocolVersion, AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION)) {
-                    this.livesyncTool.end();
-                }
-                return result;
+                const pathToLiveSyncFile = await this.$tempService.path({
+                    prefix: "livesync",
+                });
+                this.$fs.writeFile(pathToLiveSyncFile, "");
+                await this.device.fileSystem.putFile(pathToLiveSyncFile, this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
+                await this.device.applicationManager.startApplication({
+                    appId: deviceAppData.appIdentifier,
+                    projectName: this.data.projectName,
+                    justLaunch: true,
+                    waitForDebugger: false,
+                    projectDir: deviceAppData.projectDir,
+                });
+                await this.connectLivesyncTool(this.data.projectIdentifiers.android, deviceAppData.connectTimeout);
             }
-            catch (e) {
-                this.livesyncTool.end();
-                throw e;
+            catch (err) {
+                await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
+                throw err;
             }
-        });
+        }
     }
-    getCleanupCommand(appIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                command: yield this.$staticConfig.getAdbFilePath(),
-                args: [
-                    "-s",
-                    this.device.deviceInfo.identifier,
-                    "shell",
-                    "rm",
-                    "-rf",
-                    appIdentifier,
-                ],
-            };
-        });
+    getPathToLiveSyncFileOnDevice(appIdentifier) {
+        return `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
     }
-    doSync(liveSyncInfo, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operationId = this.livesyncTool.generateOperationIdentifier();
-            let result = { operationId, didRefresh: true };
-            if (liveSyncInfo.modifiedFilesData.length) {
-                const canExecuteFastSync = !liveSyncInfo.isFullSync &&
-                    this.canExecuteFastSyncForPaths(liveSyncInfo, liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
-                const doSyncPromise = this.livesyncTool.sendDoSyncOperation({
-                    doRefresh: canExecuteFastSync,
-                    operationId,
-                });
-                const syncInterval = setInterval(() => {
-                    if (this.livesyncTool.isOperationInProgress(operationId)) {
-                        this.$logger.info("Sync operation in progress...");
-                    }
-                }, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
-                const cleanupCommand = yield this.getCleanupCommand(liveSyncInfo.deviceAppData.appIdentifier);
-                const actionOnEnd = () => __awaiter(this, void 0, void 0, function* () {
-                    clearInterval(syncInterval);
-                    yield this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
-                    yield this.$cleanupService.removeCleanupCommand(cleanupCommand);
-                });
-                yield this.$cleanupService.addCleanupCommand(cleanupCommand);
-                yield doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));
-                result = yield doSyncPromise;
-            }
-            else {
-                yield this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
+    async finalizeSync(liveSyncInfo, projectData) {
+        try {
+            const result = await this.doSync(liveSyncInfo, projectData);
+            if (!semver.gte(this.livesyncTool.protocolVersion, AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION)) {
+                this.livesyncTool.end();
             }
             return result;
-        });
+        }
+        catch (e) {
+            this.livesyncTool.end();
+            throw e;
+        }
     }
-    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 (!this.$options.justlaunch &&
-                !liveSyncInfo.waitForDebugger &&
-                this.livesyncTool.protocolVersion &&
-                semver.gte(this.livesyncTool.protocolVersion, AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION)) {
-                try {
-                    yield this.connectLivesyncTool(liveSyncInfo.deviceAppData.appIdentifier);
-                }
-                catch (e) {
-                    this.$logger.trace("Failed to connect after app restart.");
-                }
-            }
-        });
+    async getCleanupCommand(appIdentifier) {
+        return {
+            command: await this.$staticConfig.getAdbFilePath(),
+            args: [
+                "-s",
+                this.device.deviceInfo.identifier,
+                "shell",
+                "rm",
+                "-rf",
+                appIdentifier,
+            ],
+        };
     }
-    shouldRestart(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let shouldRestart = false;
+    async doSync(liveSyncInfo, projectData) {
+        const operationId = this.livesyncTool.generateOperationIdentifier();
+        let result = { operationId, didRefresh: true };
+        if (liveSyncInfo.modifiedFilesData.length) {
             const canExecuteFastSync = !liveSyncInfo.isFullSync &&
                 this.canExecuteFastSyncForPaths(liveSyncInfo, liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
-            if (!canExecuteFastSync ||
-                !liveSyncInfo.didRefresh ||
-                liveSyncInfo.waitForDebugger) {
-                shouldRestart = true;
-            }
-            return shouldRestart;
-        });
+            const doSyncPromise = this.livesyncTool.sendDoSyncOperation({
+                doRefresh: canExecuteFastSync,
+                operationId,
+            });
+            const syncInterval = setInterval(() => {
+                if (this.livesyncTool.isOperationInProgress(operationId)) {
+                    this.$logger.info("Sync operation in progress...");
+                }
+            }, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
+            const cleanupCommand = await this.getCleanupCommand(liveSyncInfo.deviceAppData.appIdentifier);
+            const actionOnEnd = async () => {
+                clearInterval(syncInterval);
+                await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
+                await this.$cleanupService.removeCleanupCommand(cleanupCommand);
+            };
+            await this.$cleanupService.addCleanupCommand(cleanupCommand);
+            await doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));
+            result = await doSyncPromise;
+        }
+        else {
+            await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
+        }
+        return result;
     }
-    tryRefreshApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
+    async restartApplication(projectData, liveSyncInfo) {
+        await this.device.applicationManager.restartApplication({
+            appId: liveSyncInfo.deviceAppData.appIdentifier,
+            projectName: projectData.projectName,
+            waitForDebugger: liveSyncInfo.waitForDebugger,
+            projectDir: projectData.projectDir,
         });
+        if (!this.$options.justlaunch &&
+            !liveSyncInfo.waitForDebugger &&
+            this.livesyncTool.protocolVersion &&
+            semver.gte(this.livesyncTool.protocolVersion, AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION)) {
+            try {
+                await this.connectLivesyncTool(liveSyncInfo.deviceAppData.appIdentifier);
+            }
+            catch (e) {
+                this.$logger.trace("Failed to connect after app restart.");
+            }
+        }
     }
-    removeFiles(deviceAppData, localToDevicePaths, projectFilesPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.livesyncTool.removeFiles(_.map(localToDevicePaths, (element) => element.filePath));
-            const deviceHashService = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier);
-            yield deviceHashService.removeHashes(localToDevicePaths);
-        });
+    async shouldRestart(projectData, liveSyncInfo) {
+        let shouldRestart = false;
+        const canExecuteFastSync = !liveSyncInfo.isFullSync &&
+            this.canExecuteFastSyncForPaths(liveSyncInfo, liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
+        if (!canExecuteFastSync ||
+            !liveSyncInfo.didRefresh ||
+            liveSyncInfo.waitForDebugger) {
+            shouldRestart = true;
+        }
+        return shouldRestart;
     }
-    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const files = _.map(localToDevicePaths, (localToDevicePath) => localToDevicePath.getLocalPath());
-            yield this.livesyncTool.sendFiles(files);
-        });
+    async tryRefreshApplication(projectData, liveSyncInfo) {
+        return true;
     }
-    transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.livesyncTool.sendDirectory(projectFilesPath);
-        });
+    async removeFiles(deviceAppData, localToDevicePaths, projectFilesPath) {
+        await this.livesyncTool.removeFiles(_.map(localToDevicePaths, (element) => element.filePath));
+        const deviceHashService = this.device.fileSystem.getDeviceHashService(deviceAppData.appIdentifier);
+        await deviceHashService.removeHashes(localToDevicePaths);
     }
-    connectLivesyncTool(appIdentifier, connectTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platformData = this.platformsDataService.getPlatformData(this.$devicePlatformsConstants.Android, this.data);
-            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
-            if (!this.livesyncTool.hasConnection()) {
-                yield this.livesyncTool.connect({
-                    appIdentifier,
-                    deviceIdentifier: this.device.deviceInfo.identifier,
-                    appPlatformsPath: projectFilesPath,
-                    connectTimeout,
-                });
-            }
-        });
+    async transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        const files = _.map(localToDevicePaths, (localToDevicePath) => localToDevicePath.getLocalPath());
+        await this.livesyncTool.sendFiles(files);
+    }
+    async transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
+        await this.livesyncTool.sendDirectory(projectFilesPath);
+    }
+    async connectLivesyncTool(appIdentifier, connectTimeout) {
+        const platformData = this.platformsDataService.getPlatformData(this.$devicePlatformsConstants.Android, this.data);
+        const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+        if (!this.livesyncTool.hasConnection()) {
+            await this.livesyncTool.connect({
+                appIdentifier,
+                deviceIdentifier: this.device.deviceInfo.identifier,
+                appPlatformsPath: projectFilesPath,
+                connectTimeout,
+            });
+        }
     }
 }
+exports.AndroidDeviceSocketsLiveSyncService = AndroidDeviceSocketsLiveSyncService;
 AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL = 10000;
 AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION = "0.2.0";
-exports.AndroidDeviceSocketsLiveSyncService = AndroidDeviceSocketsLiveSyncService;