@akylas/nativescript-cli 8.7.2

package/lib/common/mobile/ios/device/ios-application-manager.js

@@ -0,0 +1,159 @@
+"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.IOSApplicationManager = void 0;
+const os_1 = require("os");
+const _ = require("lodash");
+const helpers_1 = require("../../../helpers");
+const application_manager_base_1 = require("../../application-manager-base");
+const decorators_1 = require("../../../decorators");
+class IOSApplicationManager extends application_manager_base_1.ApplicationManagerBase {
+    constructor($logger, $hooksService, device, $errors, $iOSNotificationService, $iosDeviceOperations, $options, $deviceLogProvider) {
+        super($logger, $hooksService, $deviceLogProvider);
+        this.$logger = $logger;
+        this.$hooksService = $hooksService;
+        this.device = device;
+        this.$errors = $errors;
+        this.$iOSNotificationService = $iOSNotificationService;
+        this.$iosDeviceOperations = $iosDeviceOperations;
+        this.$options = $options;
+        this.$deviceLogProvider = $deviceLogProvider;
+    }
+    getInstalledApplications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const applicationsLiveSyncStatus = yield this.getApplicationsInformation();
+            return _(applicationsLiveSyncStatus)
+                .map((appLiveSyncStatus) => appLiveSyncStatus.applicationIdentifier)
+                .sortBy((identifier) => identifier.toLowerCase())
+                .value();
+        });
+    }
+    installApplication(packageFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$iosDeviceOperations.install(packageFilePath, [this.device.deviceInfo.identifier], (err) => {
+                this.$errors.fail(`Failed to install ${packageFilePath} on device with identifier ${err.deviceId}. Error is: ${err.message}`);
+            });
+        });
+    }
+    getApplicationsInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceIdentifier = this.device.deviceInfo.identifier;
+            const applicationsOnDeviceInfo = _.first((yield this.$iosDeviceOperations.apps([deviceIdentifier]))[deviceIdentifier]);
+            const applicationsOnDevice = applicationsOnDeviceInfo
+                ? applicationsOnDeviceInfo.response
+                : [];
+            this.$logger.trace("Result when getting applications information: ", JSON.stringify(applicationsOnDevice, null, 2));
+            this.applicationsLiveSyncInfos = _.map(applicationsOnDevice, (app) => ({
+                applicationIdentifier: app.CFBundleIdentifier,
+                configuration: app.configuration,
+                deviceIdentifier: this.device.deviceInfo.identifier,
+            }));
+            return this.applicationsLiveSyncInfos;
+        });
+    }
+    uninstallApplication(appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$iosDeviceOperations.uninstall(appIdentifier, [this.device.deviceInfo.identifier], (err) => {
+                this.$logger.warn(`Failed to uninstall ${appIdentifier} on device with identifier ${err.deviceId}`);
+            });
+            this.$logger.trace("Application %s has been uninstalled successfully.", appIdentifier);
+        });
+    }
+    startApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.isApplicationInstalled(appData.appId))) {
+                this.$errors.fail("Invalid application id: %s. All available application ids are: %s%s ", appData.appId, os_1.EOL, this.applicationsLiveSyncInfos.join(os_1.EOL));
+            }
+            yield this.setDeviceLogData(appData);
+            yield this.runApplicationCore(appData);
+            this.$logger.info(`Successfully run application ${appData.appId} on device with ID ${this.device.deviceInfo.identifier}.`);
+        });
+    }
+    stopApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { appId } = appData;
+            yield this.device.destroyDebugSocket(appId);
+            const action = () => this.$iosDeviceOperations.stop([
+                {
+                    deviceId: this.device.deviceInfo.identifier,
+                    ddi: this.$options.ddi,
+                    appId,
+                },
+            ]);
+            try {
+                yield action();
+            }
+            catch (err) {
+                this.$logger.trace(`Error when trying to stop application ${appId} on device ${this.device.deviceInfo.identifier}: ${err}. Retrying stop operation.`);
+                yield action();
+            }
+        });
+    }
+    restartApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.setDeviceLogData(appData);
+                yield this.stopApplication(appData);
+                yield this.runApplicationCore(appData);
+            }
+            catch (err) {
+                yield this.$iOSNotificationService.postNotification(this.device.deviceInfo.identifier, `${appData.appId}:NativeScript.LiveSync.RestartApplication`);
+                throw err;
+            }
+        });
+    }
+    setDeviceLogData(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$deviceLogProvider.setProjectNameForDevice(this.device.deviceInfo.identifier, appData.projectName);
+            this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, appData.projectDir);
+            if (!this.$options.justlaunch) {
+                yield this.startDeviceLog();
+            }
+        });
+    }
+    runApplicationCore(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const waitForDebugger = (!!appData.waitForDebugger).toString();
+            yield this.$iosDeviceOperations.start([
+                {
+                    deviceId: this.device.deviceInfo.identifier,
+                    appId: appData.appId,
+                    ddi: this.$options.ddi,
+                    waitForDebugger,
+                },
+            ]);
+        });
+    }
+    startDeviceLog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.openDeviceLogStream();
+        });
+    }
+    getDebuggableApps() {
+        return Promise.resolve([]);
+    }
+    getDebuggableAppViews(appIdentifiers) {
+        return Promise.resolve(null);
+    }
+}
+__decorate([
+    (0, helpers_1.hook)("install")
+], IOSApplicationManager.prototype, "installApplication", null);
+__decorate([
+    (0, decorators_1.cache)()
+], IOSApplicationManager.prototype, "startDeviceLog", null);
+exports.IOSApplicationManager = IOSApplicationManager;

package/lib/common/mobile/ios/device/ios-device-file-system.js

@@ -0,0 +1,133 @@
+"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.IOSDeviceFileSystem = void 0;
+const os_1 = require("os");
+const _ = require("lodash");
+class IOSDeviceFileSystem {
+    constructor(device, $logger, $iosDeviceOperations, $fs) {
+        this.device = device;
+        this.$logger = $logger;
+        this.$iosDeviceOperations = $iosDeviceOperations;
+        this.$fs = $fs;
+    }
+    listFiles(devicePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!devicePath) {
+                devicePath = ".";
+            }
+            this.$logger.info("Listing %s", devicePath);
+            const deviceIdentifier = this.device.deviceInfo.identifier;
+            let children = [];
+            const result = yield this.$iosDeviceOperations.listDirectory([
+                { deviceId: deviceIdentifier, path: devicePath, appId: appIdentifier },
+            ]);
+            children = result[deviceIdentifier][0].response;
+            this.$logger.info(children.join(os_1.EOL));
+        });
+    }
+    getFile(deviceFilePath, appIdentifier, outputFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (outputFilePath) {
+                yield this.$iosDeviceOperations.downloadFiles([
+                    {
+                        appId: appIdentifier,
+                        deviceId: this.device.deviceInfo.identifier,
+                        source: deviceFilePath,
+                        destination: outputFilePath,
+                    },
+                ]);
+                return;
+            }
+            const fileContent = yield this.getFileContent(deviceFilePath, appIdentifier);
+            this.$logger.info(fileContent);
+        });
+    }
+    getFileContent(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.$iosDeviceOperations.readFiles([
+                {
+                    deviceId: this.device.deviceInfo.identifier,
+                    path: deviceFilePath,
+                    appId: appIdentifier,
+                },
+            ]);
+            const response = result[this.device.deviceInfo.identifier][0];
+            return response.response;
+        });
+    }
+    putFile(localFilePath, deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.uploadFilesCore([
+                {
+                    appId: appIdentifier,
+                    deviceId: this.device.deviceInfo.identifier,
+                    files: [{ source: localFilePath, destination: deviceFilePath }],
+                },
+            ]);
+        });
+    }
+    deleteFile(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$iosDeviceOperations.deleteFiles([
+                {
+                    appId: appIdentifier,
+                    destination: deviceFilePath,
+                    deviceId: this.device.deviceInfo.identifier,
+                },
+            ], (err) => {
+                this.$logger.trace(`Error while deleting file: ${deviceFilePath}: ${err.message} with code: ${err.code}`);
+                if (err.code !== IOSDeviceFileSystem.AFC_DELETE_FILE_NOT_FOUND_ERROR) {
+                    this.$logger.warn(`Cannot delete file: ${deviceFilePath}. Reason: ${err.message}`);
+                }
+            });
+        });
+    }
+    transferFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filesToUpload = _.filter(localToDevicePaths, (l) => this.$fs.getFsStats(l.getLocalPath()).isFile());
+            const files = filesToUpload.map((l) => ({
+                source: l.getLocalPath(),
+                destination: l.getDevicePath(),
+            }));
+            yield this.uploadFilesCore([
+                {
+                    deviceId: this.device.deviceInfo.identifier,
+                    appId: deviceAppData.appIdentifier,
+                    files: files,
+                },
+            ]);
+            return filesToUpload;
+        });
+    }
+    transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transferFiles(deviceAppData, localToDevicePaths);
+            return localToDevicePaths;
+        });
+    }
+    updateHashesOnDevice(hashes, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    uploadFilesCore(filesToUpload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$iosDeviceOperations.uploadFiles(filesToUpload, (err) => {
+                if (err.deviceId === this.device.deviceInfo.identifier) {
+                    throw err;
+                }
+            });
+        });
+    }
+}
+IOSDeviceFileSystem.AFC_DELETE_FILE_NOT_FOUND_ERROR = 8;
+exports.IOSDeviceFileSystem = IOSDeviceFileSystem;

package/lib/common/mobile/ios/device/ios-device-operations.js

@@ -0,0 +1,234 @@
+"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.IOSDeviceOperations = void 0;
+const ios_device_lib_1 = require("ios-device-lib");
+const decorators_1 = require("../../../decorators");
+const constants_1 = require("../../../constants");
+const _ = require("lodash");
+const assert = require("assert");
+const events_1 = require("events");
+const yok_1 = require("../../../yok");
+class IOSDeviceOperations extends events_1.EventEmitter {
+    constructor($logger) {
+        super();
+        this.$logger = $logger;
+        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);
+        });
+    }
+    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);
+                });
+            }
+        });
+    }
+    startDeviceLog(deviceIdentifier) {
+        this.assertIsInitialized();
+        this.setShouldDispose(false);
+        this.$logger.trace(`Printing device log for device with identifier: ${deviceIdentifier}.`);
+        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);
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+    uploadFiles(files, errorHandler) {
+        this.assertIsInitialized();
+        _.each(files, (f) => {
+            this.$logger.trace("Uploading files:");
+            this.$logger.trace(f.files);
+            this.$logger.trace(`For application ${f.appId} on device with identifier: ${f.deviceId}.`);
+        });
+        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);
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+    dispose(signal) {
+        if (this.shouldDispose && this.deviceLib) {
+            this.deviceLib.removeAllListeners();
+            this.deviceLib.dispose(signal);
+            this.deviceLib = null;
+            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);
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+    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);
+                    }
+                }
+                else {
+                    result.push(yield 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.");
+    }
+    attacheDeviceLogDataHandler() {
+        this.deviceLib.on(constants_1.DEVICE_LOG_EVENT_NAME, (response) => {
+            this.emit(constants_1.DEVICE_LOG_EVENT_NAME, response);
+        });
+    }
+}
+__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

@@ -0,0 +1,153 @@
+"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.IOSDevice = void 0;
+const applicationManagerPath = require("./ios-application-manager");
+const fileSystemPath = require("./ios-device-file-system");
+const commonConstants = require("../../../constants");
+const constants = require("../../../../constants");
+const net = require("net");
+const _ = require("lodash");
+const decorators_1 = require("../../../decorators");
+const helpers = require("../../../../common/helpers");
+const ios_device_base_1 = require("../ios-device-base");
+const yok_1 = require("../../../yok");
+class IOSDevice extends ios_device_base_1.IOSDeviceBase {
+    constructor(deviceActionInfo, $errors, $injector, $iOSDebuggerPortService, $deviceLogProvider, $logger, $lockService, $iOSSocketRequestExecutor, $devicePlatformsConstants, $iOSDeviceProductNameMapper, $iosDeviceOperations, $mobileHelper) {
+        super();
+        this.deviceActionInfo = deviceActionInfo;
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$iOSDebuggerPortService = $iOSDebuggerPortService;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$logger = $logger;
+        this.$lockService = $lockService;
+        this.$iOSSocketRequestExecutor = $iOSSocketRequestExecutor;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$iOSDeviceProductNameMapper = $iOSDeviceProductNameMapper;
+        this.$iosDeviceOperations = $iosDeviceOperations;
+        this.$mobileHelper = $mobileHelper;
+        this.applicationManager = this.$injector.resolve(applicationManagerPath.IOSApplicationManager, { device: this, devicePointer: this.deviceActionInfo });
+        this.fileSystem = this.$injector.resolve(fileSystemPath.IOSDeviceFileSystem, { device: this, devicePointer: this.deviceActionInfo });
+        const productType = deviceActionInfo.productType;
+        const isTablet = this.$mobileHelper.isiOSTablet(productType);
+        const deviceStatus = deviceActionInfo.status || commonConstants.UNREACHABLE_STATUS;
+        this.deviceInfo = {
+            identifier: deviceActionInfo.deviceId,
+            vendor: "Apple",
+            platform: this.getPlatform(productType),
+            status: deviceStatus,
+            errorHelp: deviceStatus === commonConstants.UNREACHABLE_STATUS
+                ? `Device ${deviceActionInfo.deviceId} is ${commonConstants.UNREACHABLE_STATUS}`
+                : null,
+            type: "Device",
+            isTablet: isTablet,
+            displayName: this.$iOSDeviceProductNameMapper.resolveProductName(deviceActionInfo.deviceName) || deviceActionInfo.deviceName,
+            model: this.$iOSDeviceProductNameMapper.resolveProductName(productType),
+            version: deviceActionInfo.productVersion,
+            color: deviceActionInfo.deviceColor,
+            activeArchitecture: this.getActiveArchitecture(productType),
+            connectionTypes: [],
+        };
+        if (deviceActionInfo.isUSBConnected) {
+            this.deviceInfo.connectionTypes.push(constants.DeviceConnectionType.USB);
+        }
+        if (deviceActionInfo.isWiFiConnected) {
+            this.deviceInfo.connectionTypes.push(constants.DeviceConnectionType.Wifi);
+        }
+    }
+    get isEmulator() {
+        return false;
+    }
+    get isOnlyWiFiConnected() {
+        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);
+            }
+        });
+    }
+    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) {
+            this.$deviceLogProvider.logData(response.message, this.$devicePlatformsConstants.iOS, this.deviceInfo.identifier);
+        }
+    }
+    detach() {
+        if (this._deviceLogHandler) {
+            this.$iosDeviceOperations.removeListener(commonConstants.DEVICE_LOG_EVENT_NAME, this._deviceLogHandler);
+        }
+    }
+    getActiveArchitecture(productType) {
+        let activeArchitecture = "";
+        if (productType) {
+            productType = productType.toLowerCase().trim();
+            const majorVersionAsString = productType.match(/.*?(\d+)\,(\d+)/)[1];
+            const majorVersion = parseInt(majorVersionAsString);
+            let isArm64Architecture = false;
+            if (_.startsWith(productType, "iphone")) {
+                isArm64Architecture = majorVersion >= 6;
+            }
+            else if (_.startsWith(productType, "ipad")) {
+                isArm64Architecture = majorVersion >= 4;
+            }
+            else if (_.startsWith(productType, "ipod")) {
+                isArm64Architecture = majorVersion >= 7;
+            }
+            else if (_.startsWith(productType, "realitydevice")) {
+                isArm64Architecture = true;
+            }
+            activeArchitecture = isArm64Architecture ? "arm64" : "armv7";
+        }
+        return activeArchitecture;
+    }
+    getPlatform(productType) {
+        productType = productType.toLowerCase().trim();
+        if (_.startsWith(productType, "realitydevice")) {
+            return this.$devicePlatformsConstants.visionOS;
+        }
+        return this.$devicePlatformsConstants.iOS;
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], IOSDevice.prototype, "openDeviceLogStream", null);
+exports.IOSDevice = IOSDevice;
+yok_1.injector.register("iOSDevice", IOSDevice);