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

package/lib/common/mobile/ios/device/ios-device-operations.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.IOSDeviceOperations = void 0;
 const ios_device_lib_1 = require("ios-device-lib");
@@ -21,45 +30,52 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         this.isInitialized = false;
         this.shouldDispose = true;
     }
-    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);
+    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);
+        });
     }
-    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;
+    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);
+        });
+    }
+    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;
+                }
+                // We need this because we need to make sure that we have devices.
+                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);
+                });
             }
-            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();
@@ -68,31 +84,39 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         this.attacheDeviceLogDataHandler();
         this.deviceLib.startDeviceLog([deviceIdentifier]);
     }
-    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);
+    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 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}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.list(listArray), 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}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.read(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}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.download(deviceFilePaths), errorHandler);
     }
     uploadFiles(files, errorHandler) {
         this.assertIsInitialized();
@@ -103,28 +127,36 @@ class IOSDeviceOperations extends events_1.EventEmitter {
         });
         return this.getMultipleResults(() => this.deviceLib.upload(files), 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}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.delete(deleteArray), errorHandler);
     }
-    async start(startArray, errorHandler) {
-        this.assertIsInitialized();
-        _.each(startArray, (s) => {
-            this.$logger.trace(`Starting application ${s.appId} on device with identifier: ${s.deviceId}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.start(startArray), errorHandler);
     }
-    async stop(stopArray, errorHandler) {
-        this.assertIsInitialized();
-        _.each(stopArray, (s) => {
-            this.$logger.trace(`Stopping application ${s.appId} on device with identifier: ${s.deviceId}.`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.stop(stopArray), errorHandler);
     }
     dispose(signal) {
+        // We need to check if we should dispose the device lib.
+        // For example we do not want to dispose it when we start printing the device logs.
         if (this.shouldDispose && this.deviceLib) {
             this.deviceLib.removeAllListeners();
             this.deviceLib.dispose(signal);
@@ -132,51 +164,59 @@ class IOSDeviceOperations extends events_1.EventEmitter {
             this.$logger.trace("IOSDeviceOperations disposed.");
         }
     }
-    async postNotification(postNotificationArray, errorHandler) {
-        this.assertIsInitialized();
-        _.each(postNotificationArray, (n) => {
-            this.$logger.trace(`Sending notification ${n.notificationName} to device with identifier: ${n.deviceId}`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.postNotification(postNotificationArray), errorHandler);
     }
-    async awaitNotificationResponse(awaitNotificationResponseArray, errorHandler) {
-        this.assertIsInitialized();
-        _.each(awaitNotificationResponseArray, (n) => {
-            this.$logger.trace(`Awaiting notification response from socket: ${n.socket} with timeout: ${n.timeout}`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.awaitNotificationResponse(awaitNotificationResponseArray), errorHandler);
     }
-    async connectToPort(connectToPortArray, errorHandler) {
-        this.assertIsInitialized();
-        _.each(connectToPortArray, (c) => {
-            this.$logger.trace(`Connecting to port ${c.port} on device with identifier: ${c.deviceId}`);
+    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);
         });
-        return this.getMultipleResults(() => this.deviceLib.connectToPort(connectToPortArray), errorHandler);
     }
     setShouldDispose(shouldDispose) {
         this.shouldDispose = shouldDispose;
     }
-    async getMultipleResults(getPromisesMethod, errorHandler) {
-        const result = [];
-        const promises = getPromisesMethod();
-        for (const promise of promises) {
-            if (errorHandler) {
-                try {
-                    result.push(await promise);
+    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);
+                    }
                 }
-                catch (err) {
-                    this.$logger.trace(`Error while executing ios device operation: ${err.message} with code: ${err.code}`);
-                    errorHandler(err);
+                else {
+                    result.push(yield promise);
                 }
             }
-            else {
-                result.push(await promise);
-            }
-        }
-        const groupedResults = _.groupBy(result, (r) => r.deviceId);
-        this.$logger.trace("Received multiple results:");
-        this.$logger.trace(groupedResults);
-        return groupedResults;
+            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.");
@@ -187,11 +227,12 @@ 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);
+//# sourceMappingURL=ios-device-operations.js.map

package/lib/common/mobile/ios/device/ios-device.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.IOSDevice = void 0;
 const applicationManagerPath = require("./ios-application-manager");
@@ -68,26 +77,33 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
         const result = this.deviceInfo.connectionTypes.every((connectionType) => connectionType === constants.DeviceConnectionType.Wifi);
         return result;
     }
-    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);
-        }
+    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 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;
+    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;
+        });
     }
     actionOnDeviceLog(response) {
         if (response.deviceId === this.deviceInfo.identifier) {
@@ -106,6 +122,7 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
             const majorVersionAsString = productType.match(/.*?(\d+)\,(\d+)/)[1];
             const majorVersion = parseInt(majorVersionAsString);
             let isArm64Architecture = false;
+            //https://en.wikipedia.org/wiki/List_of_iOS_devices
             if (_.startsWith(productType, "iphone")) {
                 isArm64Architecture = majorVersion >= 6;
             }
@@ -116,6 +133,7 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
                 isArm64Architecture = majorVersion >= 7;
             }
             else if (_.startsWith(productType, "realitydevice")) {
+                // visionos
                 isArm64Architecture = true;
             }
             activeArchitecture = isArm64Architecture ? "arm64" : "armv7";
@@ -125,13 +143,15 @@ class IOSDevice extends ios_device_base_1.IOSDeviceBase {
     getPlatform(productType) {
         productType = productType.toLowerCase().trim();
         if (_.startsWith(productType, "realitydevice")) {
+            // visionos
             return this.$devicePlatformsConstants.visionOS;
         }
         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);
+//# sourceMappingURL=ios-device.js.map

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

package/lib/common/mobile/ios/ios-device-product-name-mapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const yok_1 = require("../../yok");
 class IosDeviceProductNameMapper {
     constructor() {
+        // http://support.hockeyapp.net/kb/client-integration-ios-mac-os-x/ios-device-types
         this.map = {
             "iPhone1,1": "iPhone",
             "iPhone1,2": "iPhone 3G",
@@ -63,3 +64,4 @@ class IosDeviceProductNameMapper {
     }
 }
 yok_1.injector.register("iOSDeviceProductNameMapper", IosDeviceProductNameMapper);
+//# sourceMappingURL=ios-device-product-name-mapper.js.map

package/lib/common/mobile/ios/ios-log-filter.js

@@ -22,3 +22,4 @@ class IOSLogFilter {
 }
 exports.IOSLogFilter = IOSLogFilter;
 yok_1.injector.register("iOSLogFilter", IOSLogFilter);
+//# sourceMappingURL=ios-log-filter.js.map