@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,203 @@
+"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.AndroidDeviceLiveSyncService = void 0;
+const android_device_livesync_service_base_1 = require("./android-device-livesync-service-base");
+const decorators_1 = require("../../common/decorators");
+const helpers = require("../../common/helpers");
+const constants_1 = require("../../common/constants");
+const constants_2 = require("../../constants");
+const util = require("util");
+const path = require("path");
+const net = require("net");
+const _ = require("lodash");
+class AndroidDeviceLiveSyncService extends android_device_livesync_service_base_1.AndroidDeviceLiveSyncServiceBase {
+    constructor($mobileHelper, $devicePathProvider, $injector, $androidProcessService, platformsDataService, device, $filesHashService, $logger) {
+        super($injector, platformsDataService, $filesHashService, $logger, device);
+        this.$mobileHelper = $mobileHelper;
+        this.$devicePathProvider = $devicePathProvider;
+        this.$androidProcessService = $androidProcessService;
+        this.platformsDataService = platformsDataService;
+        this.device = device;
+    }
+    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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);
+        });
+    }
+    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,
+            });
+        });
+    }
+    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;
+        });
+    }
+    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;
+        });
+    }
+    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),
+            ]);
+        });
+    }
+    beforeLiveSyncAction(deviceAppData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceRootPath = yield this.$devicePathProvider.getDeviceProjectRootPath(deviceAppData.device, {
+                appIdentifier: deviceAppData.appIdentifier,
+                getDirname: 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);
+            if (matchingFile && matchingFile[0] && _.startsWith(matchingFile[0], "-")) {
+                yield this.device.adb.executeShellCommand(["rm", "-f", deviceRootPath]);
+            }
+            yield this.cleanLivesyncDirectories(deviceAppData);
+        });
+    }
+    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;
+        });
+    }
+    removeFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceRootPath = yield 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);
+                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;
+                    socket.destroy();
+                    resolve(true);
+                });
+                socket.on("error", () => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve(false);
+                    }
+                });
+                socket.on("close", () => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve(false);
+                    }
+                });
+            });
+        });
+    }
+}
+__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

@@ -0,0 +1,198 @@
+"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 android_livesync_tool_1 = require("./android-livesync-tool");
+const path = require("path");
+const semver = require("semver");
+const _ = require("lodash");
+class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_service_base_1.AndroidDeviceLiveSyncServiceBase {
+    constructor(data, $injector, platformsDataService, $staticConfig, $logger, device, $options, $cleanupService, $fs, $devicePlatformsConstants, $tempService, $filesHashService) {
+        super($injector, platformsDataService, $filesHashService, $logger, device);
+        this.data = data;
+        this.platformsDataService = platformsDataService;
+        this.$staticConfig = $staticConfig;
+        this.device = device;
+        this.$options = $options;
+        this.$cleanupService = $cleanupService;
+        this.$fs = $fs;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        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* () {
+            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;
+            }
+        });
+    }
+    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,
+                ],
+            };
+        });
+    }
+    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);
+            }
+            return result;
+        });
+    }
+    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.");
+                }
+            }
+        });
+    }
+    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;
+        });
+    }
+    tryRefreshApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    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);
+        });
+    }
+    transferFilesOnDevice(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = _.map(localToDevicePaths, (localToDevicePath) => localToDevicePath.getLocalPath());
+            yield this.livesyncTool.sendFiles(files);
+        });
+    }
+    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, constants_1.APP_FOLDER_NAME);
+            if (!this.livesyncTool.hasConnection()) {
+                yield this.livesyncTool.connect({
+                    appIdentifier,
+                    deviceIdentifier: this.device.deviceInfo.identifier,
+                    appPlatformsPath: projectFilesPath,
+                    connectTimeout,
+                });
+            }
+        });
+    }
+}
+AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL = 10000;
+AndroidDeviceSocketsLiveSyncService.MINIMAL_VERSION_LONG_LIVING_CONNECTION = "0.2.0";
+exports.AndroidDeviceSocketsLiveSyncService = AndroidDeviceSocketsLiveSyncService;

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

@@ -0,0 +1,76 @@
+"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.AndroidLiveSyncService = void 0;
+const android_device_livesync_service_1 = require("./android-device-livesync-service");
+const android_device_livesync_sockets_service_1 = require("./android-device-livesync-sockets-service");
+const platform_livesync_service_base_1 = require("./platform-livesync-service-base");
+const decorators_1 = require("../../common/decorators");
+const semver = require("semver");
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class AndroidLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSyncServiceBase {
+    constructor($platformsDataService, $projectFilesManager, $injector, $devicePathProvider, $fs, $logger) {
+        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider);
+        this.$platformsDataService = $platformsDataService;
+        this.$projectFilesManager = $projectFilesManager;
+        this.$injector = $injector;
+    }
+    _getDeviceLiveSyncService(device, data, frameworkVersion) {
+        if (semver.gt(frameworkVersion, AndroidLiveSyncService.MIN_SOCKETS_LIVESYNC_RUNTIME_VERSION)) {
+            return this.$injector.resolve(android_device_livesync_sockets_service_1.AndroidDeviceSocketsLiveSyncService, { device, data });
+        }
+        return this.$injector.resolve(android_device_livesync_service_1.AndroidDeviceLiveSyncService, { device, data });
+    }
+    liveSyncWatchAction(device, liveSyncInfo) {
+        const _super = Object.create(null, {
+            liveSyncWatchAction: { get: () => super.liveSyncWatchAction }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncResult = yield _super.liveSyncWatchAction.call(this, device, liveSyncInfo);
+            const result = yield this.finalizeSync(device, liveSyncInfo.projectData, liveSyncResult);
+            return result;
+        });
+    }
+    fullSync(syncInfo) {
+        const _super = Object.create(null, {
+            fullSync: { get: () => super.fullSync }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncResult = yield _super.fullSync.call(this, syncInfo);
+            const result = yield this.finalizeSync(syncInfo.device, syncInfo.projectData, liveSyncResult);
+            return result;
+        });
+    }
+    finalizeSync(device, projectData, liveSyncResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncService = (this.getDeviceLiveSyncService(device, projectData));
+            const finalizeResult = yield liveSyncService.finalizeSync(liveSyncResult, projectData);
+            const result = _.extend(liveSyncResult, finalizeResult);
+            return result;
+        });
+    }
+}
+AndroidLiveSyncService.MIN_SOCKETS_LIVESYNC_RUNTIME_VERSION = "4.2.0-2018-07-20-02";
+__decorate([
+    (0, decorators_1.performanceLog)()
+], AndroidLiveSyncService.prototype, "liveSyncWatchAction", null);
+__decorate([
+    (0, decorators_1.performanceLog)()
+], AndroidLiveSyncService.prototype, "fullSync", null);
+exports.AndroidLiveSyncService = AndroidLiveSyncService;
+yok_1.injector.register("androidLiveSyncService", AndroidLiveSyncService);