nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -5,6 +5,15 @@ 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");
@@ -25,150 +34,172 @@ class AndroidDeviceLiveSyncService extends android_device_livesync_service_base_
         this.platformsDataService = platformsDataService;
         this.device = device;
     }
-    async transferFilesOnDevice(deviceAppData, localToDevicePaths) {
-        await this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
-    }
-    async transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
-        await this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
+    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
+        });
     }
-    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,
+    transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
         });
     }
-    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;
+    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 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,
+    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;
         });
-        await this.device.adb.executeShellCommand([
-            "chmod",
-            "777",
-            path.dirname(deviceProjectRootDirname),
-            deviceProjectRootDirname,
-            `${deviceProjectRootDirname}/sync`,
-        ]);
-        didRefresh = await this.reloadApplicationFiles(deviceAppData, localToDevicePaths);
-        return didRefresh;
     }
-    async cleanLivesyncDirectories(deviceAppData) {
-        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
-            appIdentifier: deviceAppData.appIdentifier,
-            getDirname: true,
+    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;
         });
-        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),
-        ]);
     }
-    async beforeLiveSyncAction(deviceAppData) {
-        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
-            appIdentifier: deviceAppData.appIdentifier,
-            getDirname: true,
+    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),
+            ]);
         });
-        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);
     }
-    async reloadApplicationFiles(deviceAppData, localToDevicePaths) {
-        if (!this.port) {
-            this.port = await this.$androidProcessService.forwardFreeTcpToAbstractPort({
-                deviceIdentifier: deviceAppData.device.deviceInfo.identifier,
+    beforeLiveSyncAction(deviceAppData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
                 appIdentifier: deviceAppData.appIdentifier,
-                abstractPort: `localabstract:${deviceAppData.appIdentifier}-livesync`,
+                getDirname: true,
             });
-        }
-        if (await this.awaitRuntimeReloadSuccessMessage()) {
-            await this.cleanLivesyncDirectories(deviceAppData);
-        }
-        else {
-            return false;
-        }
-        return true;
+            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);
+            // Check if there is already a file with deviceRootBasename. If so, delete it as it breaks LiveSyncing.
+            if (matchingFile && matchingFile[0] && _.startsWith(matchingFile[0], "-")) {
+                yield this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
+            }
+            yield this.cleanLivesyncDirectories(deviceAppData);
+        });
     }
-    async removeFiles(deviceAppData, localToDevicePaths) {
-        const deviceRootPath = await this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
-            appIdentifier: deviceAppData.appIdentifier,
-            getDirname: 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;
         });
-        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);
     }
-    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]));
-            });
-            socket.on("data", (data) => {
-                isResolved = true;
-                socket.destroy();
-                resolve(true);
-            });
-            socket.on("error", () => {
-                if (!isResolved) {
-                    isResolved = true;
-                    resolve(false);
-                }
+    removeFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+                appIdentifier: deviceAppData.appIdentifier,
+                getDirname: true,
             });
-            socket.on("close", () => {
-                if (!isResolved) {
+            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) => {
                     isResolved = true;
-                    resolve(false);
-                }
+                    socket.destroy();
+                    resolve(true);
+                });
+                socket.on("error", () => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve(false);
+                    }
+                });
+                socket.on("close", () => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        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;
+//# sourceMappingURL=android-device-livesync-service.js.map

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

@@ -1,4 +1,13 @@
 "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");
@@ -21,146 +30,171 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
         this.$tempService = $tempService;
         this.livesyncTool = this.$injector.resolve(android_livesync_tool_1.AndroidLivesyncTool);
     }
-    async beforeLiveSyncAction(deviceAppData) {
-        if (!this.livesyncTool.hasConnection()) {
-            try {
-                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 (err) {
-                await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
-                throw err;
+    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_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
     }
-    async finalizeSync(liveSyncInfo, projectData) {
-        try {
-            const result = await this.doSync(liveSyncInfo, projectData);
-            if (!semver.gte(this.livesyncTool.protocolVersion, AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION)) {
+    finalizeSync(liveSyncInfo, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+            }
+            catch (e) {
                 this.livesyncTool.end();
+                throw e;
             }
-            return result;
-        }
-        catch (e) {
-            this.livesyncTool.end();
-            throw e;
-        }
-    }
-    async getCleanupCommand(appIdentifier) {
-        return {
-            command: await this.$staticConfig.getAdbFilePath(),
-            args: [
-                "-s",
-                this.device.deviceInfo.identifier,
-                "shell",
-                "rm",
-                "-rf",
-                appIdentifier,
-            ],
-        };
+        });
     }
-    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);
-            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);
+    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,
+                ],
             };
-            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;
-    }
-    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);
+    }
+    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);
+                // We need to clear resources when the action fails
+                // But we also need the real result of the action.
+                yield doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));
+                result = yield doSyncPromise;
             }
-            catch (e) {
-                this.$logger.trace("Failed to connect after app restart.");
+            else {
+                yield this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
             }
-        }
+            return result;
+        });
     }
-    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;
+    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 tryRefreshApplication(projectData, liveSyncInfo) {
-        return true;
+    shouldRestart(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
     }
-    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);
+    tryRefreshApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
     }
-    async transferFilesOnDevice(deviceAppData, localToDevicePaths) {
-        const files = _.map(localToDevicePaths, (localToDevicePath) => localToDevicePath.getLocalPath());
-        await this.livesyncTool.sendFiles(files);
+    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 transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
-        await this.livesyncTool.sendDirectory(projectFilesPath);
+    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = _.map(localToDevicePaths, (localToDevicePath) => localToDevicePath.getLocalPath());
+            yield this.livesyncTool.sendFiles(files);
+        });
     }
-    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,
-            });
-        }
+    transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.livesyncTool.sendDirectory(projectFilesPath);
+        });
+    }
+    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, this.$options.hostProjectModuleName);
+            if (!this.livesyncTool.hasConnection()) {
+                yield 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;
+//# sourceMappingURL=android-device-livesync-sockets-service.js.map