nativescript 8.9.0-alpha.3 → 8.9.0-dev.1

package/lib/common/mobile/ios/device/ios-device-operations.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.IOSDeviceOperations = void 0;
 const ios_device_lib_1 = require("ios-device-lib");
@@ -30,51 +21,45 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         this.isInitialized = false;
         this.shouldDispose = true;
     }
-    install(ipaPath, deviceIdentifiers, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            this.$logger.trace(`Installing ${ipaPath} on devices with identifiers: ${deviceIdentifiers}.`);
-            return yield this.getMultipleResults(() => this.deviceLib.install(ipaPath, deviceIdentifiers), errorHandler);
-        });
-    }
-    uninstall(appIdentifier, deviceIdentifiers, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            this.$logger.trace(`Uninstalling ${appIdentifier} from devices with identifiers: ${deviceIdentifiers}.`);
-            return yield this.getMultipleResults(() => this.deviceLib.uninstall(appIdentifier, deviceIdentifiers), errorHandler);
-        });
+    async install(ipaPath, deviceIdentifiers, errorHandler) {
+        this.assertIsInitialized();
+        this.$logger.trace(`Installing ${ipaPath} on devices with identifiers: ${deviceIdentifiers}.`);
+        return await this.getMultipleResults(() => this.deviceLib.install(ipaPath, deviceIdentifiers), errorHandler);
     }
-    startLookingForDevices(deviceFoundCallback, deviceUpdatedCallback, deviceLostCallback, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.trace("Starting to look for iOS devices.");
-            this.isInitialized = true;
-            if (!this.deviceLib) {
-                let foundDevice = false;
-                const wrappedDeviceFoundCallback = (deviceInfo) => {
-                    foundDevice = true;
-                    return deviceFoundCallback(deviceInfo);
-                };
-                this.deviceLib = new ios_device_lib_1.IOSDeviceLib(wrappedDeviceFoundCallback, deviceUpdatedCallback, deviceLostCallback);
-                if (options && options.shouldReturnImmediateResult) {
-                    return;
-                }
-                yield new Promise((resolve, reject) => {
-                    let iterationsCount = 0;
-                    const maxIterationsCount = 3;
-                    const intervalHandle = setInterval(() => {
-                        if (foundDevice && !options.fullDiscovery) {
-                            resolve();
-                            return clearInterval(intervalHandle);
-                        }
-                        iterationsCount++;
-                        if (iterationsCount >= maxIterationsCount) {
-                            clearInterval(intervalHandle);
-                            return resolve();
-                        }
-                    }, 2000);
-                });
+    async uninstall(appIdentifier, deviceIdentifiers, errorHandler) {
+        this.assertIsInitialized();
+        this.$logger.trace(`Uninstalling ${appIdentifier} from devices with identifiers: ${deviceIdentifiers}.`);
+        return await this.getMultipleResults(() => this.deviceLib.uninstall(appIdentifier, deviceIdentifiers), errorHandler);
+    }
+    async startLookingForDevices(deviceFoundCallback, deviceUpdatedCallback, deviceLostCallback, options) {
+        this.$logger.trace("Starting to look for iOS devices.");
+        this.isInitialized = true;
+        if (!this.deviceLib) {
+            let foundDevice = false;
+            const wrappedDeviceFoundCallback = (deviceInfo) => {
+                foundDevice = true;
+                return deviceFoundCallback(deviceInfo);
+            };
+            this.deviceLib = new ios_device_lib_1.IOSDeviceLib(wrappedDeviceFoundCallback, deviceUpdatedCallback, deviceLostCallback);
+            if (options && options.shouldReturnImmediateResult) {
+                return;
             }
-        });
+            await new Promise((resolve, reject) => {
+                let iterationsCount = 0;
+                const maxIterationsCount = 3;
+                const intervalHandle = setInterval(() => {
+                    if (foundDevice && !options.fullDiscovery) {
+                        resolve();
+                        return clearInterval(intervalHandle);
+                    }
+                    iterationsCount++;
+                    if (iterationsCount >= maxIterationsCount) {
+                        clearInterval(intervalHandle);
+                        return resolve();
+                    }
+                }, 2000);
+            });
+        }
     }
     startDeviceLog(deviceIdentifier) {
         this.assertIsInitialized();
@@ -83,39 +68,31 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         this.attacheDeviceLogDataHandler();
         this.deviceLib.startDeviceLog([deviceIdentifier]);
     }
-    apps(deviceIdentifiers, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            this.$logger.trace(`Getting applications information for devices with identifiers: ${deviceIdentifiers}`);
-            return this.getMultipleResults(() => this.deviceLib.apps(deviceIdentifiers), errorHandler);
-        });
+    async apps(deviceIdentifiers, errorHandler) {
+        this.assertIsInitialized();
+        this.$logger.trace(`Getting applications information for devices with identifiers: ${deviceIdentifiers}`);
+        return this.getMultipleResults(() => this.deviceLib.apps(deviceIdentifiers), errorHandler);
     }
-    listDirectory(listArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(listArray, (l) => {
-                this.$logger.trace(`Listing directory: ${l.path} for application ${l.appId} on device with identifier: ${l.deviceId}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.list(listArray), errorHandler);
+    async listDirectory(listArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(listArray, (l) => {
+            this.$logger.trace(`Listing directory: ${l.path} for application ${l.appId} on device with identifier: ${l.deviceId}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.list(listArray), errorHandler);
     }
-    readFiles(deviceFilePaths, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(deviceFilePaths, (p) => {
-                this.$logger.trace(`Reading file: ${p.path} from application ${p.appId} on device with identifier: ${p.deviceId}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.read(deviceFilePaths), errorHandler);
+    async readFiles(deviceFilePaths, errorHandler) {
+        this.assertIsInitialized();
+        _.each(deviceFilePaths, (p) => {
+            this.$logger.trace(`Reading file: ${p.path} from application ${p.appId} on device with identifier: ${p.deviceId}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.read(deviceFilePaths), errorHandler);
     }
-    downloadFiles(deviceFilePaths, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(deviceFilePaths, (d) => {
-                this.$logger.trace(`Downloading file: ${d.source} from application ${d.appId} on device with identifier: ${d.deviceId} to ${d.destination}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.download(deviceFilePaths), errorHandler);
+    async downloadFiles(deviceFilePaths, errorHandler) {
+        this.assertIsInitialized();
+        _.each(deviceFilePaths, (d) => {
+            this.$logger.trace(`Downloading file: ${d.source} from application ${d.appId} on device with identifier: ${d.deviceId} to ${d.destination}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.download(deviceFilePaths), errorHandler);
     }
     uploadFiles(files, errorHandler) {
         this.assertIsInitialized();
@@ -126,32 +103,26 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         });
         return this.getMultipleResults(() => this.deviceLib.upload(files), errorHandler);
     }
-    deleteFiles(deleteArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(deleteArray, (d) => {
-                this.$logger.trace(`Deleting file: ${d.destination} from application ${d.appId} on device with identifier: ${d.deviceId}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.delete(deleteArray), errorHandler);
+    async deleteFiles(deleteArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(deleteArray, (d) => {
+            this.$logger.trace(`Deleting file: ${d.destination} from application ${d.appId} on device with identifier: ${d.deviceId}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.delete(deleteArray), errorHandler);
     }
-    start(startArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(startArray, (s) => {
-                this.$logger.trace(`Starting application ${s.appId} on device with identifier: ${s.deviceId}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.start(startArray), errorHandler);
+    async start(startArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(startArray, (s) => {
+            this.$logger.trace(`Starting application ${s.appId} on device with identifier: ${s.deviceId}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.start(startArray), errorHandler);
     }
-    stop(stopArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(stopArray, (s) => {
-                this.$logger.trace(`Stopping application ${s.appId} on device with identifier: ${s.deviceId}.`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.stop(stopArray), errorHandler);
+    async stop(stopArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(stopArray, (s) => {
+            this.$logger.trace(`Stopping application ${s.appId} on device with identifier: ${s.deviceId}.`);
         });
+        return this.getMultipleResults(() => this.deviceLib.stop(stopArray), errorHandler);
     }
     dispose(signal) {
         if (this.shouldDispose && this.deviceLib) {
@@ -161,59 +132,51 @@ class IOSDeviceOperations extends events_1.EventEmitter {
             this.$logger.trace("IOSDeviceOperations disposed.");
         }
     }
-    postNotification(postNotificationArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(postNotificationArray, (n) => {
-                this.$logger.trace(`Sending notification ${n.notificationName} to device with identifier: ${n.deviceId}`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.postNotification(postNotificationArray), errorHandler);
+    async postNotification(postNotificationArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(postNotificationArray, (n) => {
+            this.$logger.trace(`Sending notification ${n.notificationName} to device with identifier: ${n.deviceId}`);
         });
+        return this.getMultipleResults(() => this.deviceLib.postNotification(postNotificationArray), errorHandler);
     }
-    awaitNotificationResponse(awaitNotificationResponseArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(awaitNotificationResponseArray, (n) => {
-                this.$logger.trace(`Awaiting notification response from socket: ${n.socket} with timeout: ${n.timeout}`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.awaitNotificationResponse(awaitNotificationResponseArray), errorHandler);
+    async awaitNotificationResponse(awaitNotificationResponseArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(awaitNotificationResponseArray, (n) => {
+            this.$logger.trace(`Awaiting notification response from socket: ${n.socket} with timeout: ${n.timeout}`);
         });
+        return this.getMultipleResults(() => this.deviceLib.awaitNotificationResponse(awaitNotificationResponseArray), errorHandler);
     }
-    connectToPort(connectToPortArray, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertIsInitialized();
-            _.each(connectToPortArray, (c) => {
-                this.$logger.trace(`Connecting to port ${c.port} on device with identifier: ${c.deviceId}`);
-            });
-            return this.getMultipleResults(() => this.deviceLib.connectToPort(connectToPortArray), errorHandler);
+    async connectToPort(connectToPortArray, errorHandler) {
+        this.assertIsInitialized();
+        _.each(connectToPortArray, (c) => {
+            this.$logger.trace(`Connecting to port ${c.port} on device with identifier: ${c.deviceId}`);
         });
+        return this.getMultipleResults(() => this.deviceLib.connectToPort(connectToPortArray), errorHandler);
     }
     setShouldDispose(shouldDispose) {
         this.shouldDispose = shouldDispose;
     }
-    getMultipleResults(getPromisesMethod, errorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = [];
-            const promises = getPromisesMethod();
-            for (const promise of promises) {
-                if (errorHandler) {
-                    try {
-                        result.push(yield promise);
-                    }
-                    catch (err) {
-                        this.$logger.trace(`Error while executing ios device operation: ${err.message} with code: ${err.code}`);
-                        errorHandler(err);
-                    }
+    async getMultipleResults(getPromisesMethod, errorHandler) {
+        const result = [];
+        const promises = getPromisesMethod();
+        for (const promise of promises) {
+            if (errorHandler) {
+                try {
+                    result.push(await promise);
                 }
-                else {
-                    result.push(yield promise);
+                catch (err) {
+                    this.$logger.trace(`Error while executing ios device operation: ${err.message} with code: ${err.code}`);
+                    errorHandler(err);
                 }
             }
-            const groupedResults = _.groupBy(result, (r) => r.deviceId);
-            this.$logger.trace("Received multiple results:");
-            this.$logger.trace(groupedResults);
-            return groupedResults;
-        });
+            else {
+                result.push(await promise);
+            }
+        }
+        const groupedResults = _.groupBy(result, (r) => r.deviceId);
+        this.$logger.trace("Received multiple results:");
+        this.$logger.trace(groupedResults);
+        return groupedResults;
     }
     assertIsInitialized() {
         assert.ok(this.isInitialized, "iOS device operations not initialized.");
@@ -224,11 +187,11 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         });
     }
 }
+exports.IOSDeviceOperations = IOSDeviceOperations;
 __decorate([
     (0, decorators_1.cache)()
 ], IOSDeviceOperations.prototype, "startLookingForDevices", null);
 __decorate([
     (0, decorators_1.cache)()
 ], IOSDeviceOperations.prototype, "attacheDeviceLogDataHandler", null);
-exports.IOSDeviceOperations = IOSDeviceOperations;
 yok_1.injector.register("iosDeviceOperations", IOSDeviceOperations);

package/lib/common/mobile/ios/device/ios-device.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.IOSDevice = void 0;
 const applicationManagerPath = require("./ios-application-manager");
@@ -77,33 +68,26 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
         const result = this.deviceInfo.connectionTypes.every((connectionType) => connectionType === constants.DeviceConnectionType.Wifi);
         return result;
     }
-    openDeviceLogStream() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.deviceInfo.status !== commonConstants.UNREACHABLE_STATUS) {
-                this._deviceLogHandler = this.actionOnDeviceLog.bind(this);
-                this.$iosDeviceOperations.on(commonConstants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
-                this.$iosDeviceOperations.startDeviceLog(this.deviceInfo.identifier);
-            }
-        });
+    async openDeviceLogStream() {
+        if (this.deviceInfo.status !== commonConstants.UNREACHABLE_STATUS) {
+            this._deviceLogHandler = this.actionOnDeviceLog.bind(this);
+            this.$iosDeviceOperations.on(commonConstants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
+            this.$iosDeviceOperations.startDeviceLog(this.deviceInfo.identifier);
+        }
     }
-    getDebugSocketCore(appId) {
-        const _super = Object.create(null, {
-            getDebuggerPort: { get: () => super.getDebuggerPort }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$iOSSocketRequestExecutor.executeAttachRequest(this, constants.AWAIT_NOTIFICATION_TIMEOUT_SECONDS, appId);
-            const port = yield _super.getDebuggerPort.call(this, appId);
-            const deviceId = this.deviceInfo.identifier;
-            const socket = yield helpers.connectEventuallyUntilTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                const deviceResponse = _.first((yield this.$iosDeviceOperations.connectToPort([
-                    { deviceId: deviceId, port: port },
-                ]))[deviceId]);
-                const _socket = new net.Socket();
-                _socket.connect(deviceResponse.port, deviceResponse.host);
-                return _socket;
-            }), commonConstants.SOCKET_CONNECTION_TIMEOUT_MS);
-            return socket;
-        });
+    async getDebugSocketCore(appId) {
+        await this.$iOSSocketRequestExecutor.executeAttachRequest(this, constants.AWAIT_NOTIFICATION_TIMEOUT_SECONDS, appId);
+        const port = await super.getDebuggerPort(appId);
+        const deviceId = this.deviceInfo.identifier;
+        const socket = await helpers.connectEventuallyUntilTimeout(async () => {
+            const deviceResponse = _.first((await this.$iosDeviceOperations.connectToPort([
+                { deviceId: deviceId, port: port },
+            ]))[deviceId]);
+            const _socket = new net.Socket();
+            _socket.connect(deviceResponse.port, deviceResponse.host);
+            return _socket;
+        }, commonConstants.SOCKET_CONNECTION_TIMEOUT_MS);
+        return socket;
     }
     actionOnDeviceLog(response) {
         if (response.deviceId === this.deviceInfo.identifier) {
@@ -146,8 +130,8 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
         return this.$devicePlatformsConstants.iOS;
     }
 }
+exports.IOSDevice = IOSDevice;
 __decorate([
     (0, decorators_1.cache)()
 ], IOSDevice.prototype, "openDeviceLogStream", null);
-exports.IOSDevice = IOSDevice;
 yok_1.injector.register("iOSDevice", IOSDevice);

package/lib/common/mobile/ios/ios-device-base.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.IOSDeviceBase = void 0;
 const decorators_1 = require("../../decorators");
@@ -21,88 +12,74 @@ class IOSDeviceBase {
     constructor() {
         this.cachedSockets = {};
     }
-    getDebugSocket(appId, projectName, projectDir, ensureAppStarted = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$lockService.executeActionWithLock(() => __awaiter(this, void 0, void 0, function* () {
-                if (this.cachedSockets[appId]) {
-                    return this.cachedSockets[appId];
-                }
-                yield this.attachToDebuggerFoundEvent(appId, projectName, projectDir);
-                try {
-                    if (ensureAppStarted) {
-                        yield this.applicationManager.startApplication({
-                            appId,
-                            projectName,
-                            projectDir,
-                        });
-                    }
-                }
-                catch (err) {
-                    this.$logger.trace(`Unable to start application ${appId} on device ${this.deviceInfo.identifier} in getDebugSocket method. Error is: ${err}`);
-                }
-                this.cachedSockets[appId] = yield this.getDebugSocketCore(appId);
-                if (this.cachedSockets[appId]) {
-                    this.cachedSockets[appId].on("close", () => __awaiter(this, void 0, void 0, function* () {
-                        yield this.destroyDebugSocket(appId);
-                    }));
-                }
+    async getDebugSocket(appId, projectName, projectDir, ensureAppStarted = false) {
+        return this.$lockService.executeActionWithLock(async () => {
+            if (this.cachedSockets[appId]) {
                 return this.cachedSockets[appId];
-            }), `ios-debug-socket-${this.deviceInfo.identifier}-${appId}.lock`);
-        });
+            }
+            await this.attachToDebuggerFoundEvent(appId, projectName, projectDir);
+            try {
+                if (ensureAppStarted) {
+                    await this.applicationManager.startApplication({
+                        appId,
+                        projectName,
+                        projectDir,
+                    });
+                }
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to start application ${appId} on device ${this.deviceInfo.identifier} in getDebugSocket method. Error is: ${err}`);
+            }
+            this.cachedSockets[appId] = await this.getDebugSocketCore(appId);
+            if (this.cachedSockets[appId]) {
+                this.cachedSockets[appId].on("close", async () => {
+                    await this.destroyDebugSocket(appId);
+                });
+            }
+            return this.cachedSockets[appId];
+        }, `ios-debug-socket-${this.deviceInfo.identifier}-${appId}.lock`);
     }
-    attachToDebuggerFoundEvent(appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.startDeviceLogProcess(projectName, projectDir);
-            yield this.$iOSDebuggerPortService.attachToDebuggerPortFoundEvent(appId);
-        });
+    async attachToDebuggerFoundEvent(appId, projectName, projectDir) {
+        await this.startDeviceLogProcess(projectName, projectDir);
+        await this.$iOSDebuggerPortService.attachToDebuggerPortFoundEvent(appId);
     }
-    getDebuggerPort(appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const port = yield this.$iOSDebuggerPortService.getPort({
-                deviceId: this.deviceInfo.identifier,
-                appId,
-            });
-            if (!port) {
-                this.$errors.fail("Device socket port cannot be found.");
-            }
-            return port;
+    async getDebuggerPort(appId) {
+        const port = await this.$iOSDebuggerPortService.getPort({
+            deviceId: this.deviceInfo.identifier,
+            appId,
         });
+        if (!port) {
+            this.$errors.fail("Device socket port cannot be found.");
+        }
+        return port;
     }
-    destroyAllSockets() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const appId in this.cachedSockets) {
-                yield this.destroySocketSafe(this.cachedSockets[appId]);
-            }
-            this.cachedSockets = {};
-        });
+    async destroyAllSockets() {
+        for (const appId in this.cachedSockets) {
+            await this.destroySocketSafe(this.cachedSockets[appId]);
+        }
+        this.cachedSockets = {};
     }
-    destroyDebugSocket(appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.destroySocketSafe(this.cachedSockets[appId]);
-            this.cachedSockets[appId] = null;
-        });
+    async destroyDebugSocket(appId) {
+        await this.destroySocketSafe(this.cachedSockets[appId]);
+        this.cachedSockets[appId] = null;
     }
-    destroySocketSafe(socket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (socket && !socket.destroyed) {
-                return new Promise((resolve, reject) => {
-                    socket.on("close", resolve);
-                    socket.destroy();
-                });
-            }
-        });
+    async destroySocketSafe(socket) {
+        if (socket && !socket.destroyed) {
+            return new Promise((resolve, reject) => {
+                socket.on("close", resolve);
+                socket.destroy();
+            });
+        }
     }
-    startDeviceLogProcess(projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (projectName) {
-                this.$deviceLogProvider.setProjectNameForDevice(this.deviceInfo.identifier, projectName);
-                this.$deviceLogProvider.setProjectDirForDevice(this.deviceInfo.identifier, projectDir);
-            }
-            yield this.openDeviceLogStream();
-        });
+    async startDeviceLogProcess(projectName, projectDir) {
+        if (projectName) {
+            this.$deviceLogProvider.setProjectNameForDevice(this.deviceInfo.identifier, projectName);
+            this.$deviceLogProvider.setProjectDirForDevice(this.deviceInfo.identifier, projectDir);
+        }
+        await this.openDeviceLogStream();
     }
 }
+exports.IOSDeviceBase = IOSDeviceBase;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], IOSDeviceBase.prototype, "getDebugSocket", null);
-exports.IOSDeviceBase = IOSDeviceBase;