nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/common/mobile/emulator-helper.js

@@ -6,6 +6,7 @@ const _ = require("lodash");
 const yok_1 = require("../yok");
 class EmulatorHelper {
     constructor() {
+        // https://developer.android.com/guide/topics/manifest/uses-sdk-element
         this.mapAndroidApiLevelToVersion = {
             "android-35": "15.0.0",
             "android-34": "14.0.0",
@@ -79,7 +80,9 @@ class EmulatorHelper {
         emulator.identifier = emulatorId;
         emulator.status = constants_1.RUNNING_EMULATOR_STATUS;
         emulator.type = constants_1.DeviceTypes.Device;
+        //emulator.isTablet; // TODO: consider to do this here!!!
     }
 }
 exports.EmulatorHelper = EmulatorHelper;
 yok_1.injector.register("emulatorHelper", EmulatorHelper);
+//# sourceMappingURL=emulator-helper.js.map

package/lib/common/mobile/ios/device/ios-application-manager.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.IOSApplicationManager = void 0;
 const os_1 = require("os");
@@ -24,107 +33,130 @@ class IOSApplicationManager extends application_manager_base_1.ApplicationManage
         this.$options = $options;
         this.$deviceLogProvider = $deviceLogProvider;
     }
-    async getInstalledApplications() {
-        const applicationsLiveSyncStatus = await this.getApplicationsInformation();
-        return _(applicationsLiveSyncStatus)
-            .map((appLiveSyncStatus) => appLiveSyncStatus.applicationIdentifier)
-            .sortBy((identifier) => identifier.toLowerCase())
-            .value();
+    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();
+        });
     }
-    async installApplication(packageFilePath) {
-        await 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}`);
+    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}`);
+            });
         });
     }
-    async getApplicationsInformation() {
-        const deviceIdentifier = this.device.deviceInfo.identifier;
-        const applicationsOnDeviceInfo = _.first((await 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;
+    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;
+        });
     }
-    async uninstallApplication(appIdentifier) {
-        await this.$iosDeviceOperations.uninstall(appIdentifier, [this.device.deviceInfo.identifier], (err) => {
-            this.$logger.warn(`Failed to uninstall ${appIdentifier} on device with identifier ${err.deviceId}`);
+    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);
         });
-        this.$logger.trace("Application %s has been uninstalled successfully.", appIdentifier);
     }
-    async startApplication(appData) {
-        if (!(await 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));
-        }
-        await this.setDeviceLogData(appData);
-        await this.runApplicationCore(appData);
-        this.$logger.info(`Successfully run application ${appData.appId} on device with ID ${this.device.deviceInfo.identifier}.`);
+    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}.`);
+        });
     }
-    async stopApplication(appData) {
-        const { appId } = appData;
-        await this.device.destroyDebugSocket(appId);
-        const action = () => this.$iosDeviceOperations.stop([
-            {
-                deviceId: this.device.deviceInfo.identifier,
-                ddi: this.$options.ddi,
-                appId,
-            },
-        ]);
-        try {
-            await action();
-        }
-        catch (err) {
-            this.$logger.trace(`Error when trying to stop application ${appId} on device ${this.device.deviceInfo.identifier}: ${err}. Retrying stop operation.`);
-            await action();
-        }
+    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();
+            }
+        });
     }
-    async restartApplication(appData) {
-        try {
-            await this.setDeviceLogData(appData);
-            await this.stopApplication(appData);
-            await this.runApplicationCore(appData);
-        }
-        catch (err) {
-            await this.$iOSNotificationService.postNotification(this.device.deviceInfo.identifier, `${appData.appId}:NativeScript.LiveSync.RestartApplication`);
-            throw err;
-        }
+    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;
+            }
+        });
     }
-    async setDeviceLogData(appData) {
-        this.$deviceLogProvider.setProjectNameForDevice(this.device.deviceInfo.identifier, appData.projectName);
-        this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, appData.projectDir);
-        if (!this.$options.justlaunch) {
-            await this.startDeviceLog();
-        }
+    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();
+            }
+        });
     }
-    async runApplicationCore(appData) {
-        const waitForDebugger = (!!appData.waitForDebugger).toString();
-        await this.$iosDeviceOperations.start([
-            {
-                deviceId: this.device.deviceInfo.identifier,
-                appId: appData.appId,
-                ddi: this.$options.ddi,
-                waitForDebugger,
-            },
-        ]);
+    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,
+                },
+            ]);
+        });
     }
-    async startDeviceLog() {
-        await this.device.openDeviceLogStream();
+    startDeviceLog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.openDeviceLogStream();
+        });
     }
     getDebuggableApps() {
+        // Implement when we can find debuggable applications for iOS.
         return Promise.resolve([]);
     }
     getDebuggableAppViews(appIdentifiers) {
+        // Implement when we can find debuggable applications for iOS.
         return Promise.resolve(null);
     }
 }
-exports.IOSApplicationManager = IOSApplicationManager;
 __decorate([
     (0, helpers_1.hook)("install")
 ], IOSApplicationManager.prototype, "installApplication", null);
 __decorate([
     (0, decorators_1.cache)()
 ], IOSApplicationManager.prototype, "startDeviceLog", null);
+exports.IOSApplicationManager = IOSApplicationManager;
+//# sourceMappingURL=ios-application-manager.js.map

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

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IOSDeviceFileSystem = void 0;
 const os_1 = require("os");
@@ -10,97 +19,116 @@ class IOSDeviceFileSystem {
         this.$iosDeviceOperations = $iosDeviceOperations;
         this.$fs = $fs;
     }
-    async listFiles(devicePath, appIdentifier) {
-        if (!devicePath) {
-            devicePath = ".";
-        }
-        this.$logger.info("Listing %s", devicePath);
-        const deviceIdentifier = this.device.deviceInfo.identifier;
-        let children = [];
-        const result = await this.$iosDeviceOperations.listDirectory([
-            { deviceId: deviceIdentifier, path: devicePath, appId: appIdentifier },
-        ]);
-        children = result[deviceIdentifier][0].response;
-        this.$logger.info(children.join(os_1.EOL));
+    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));
+        });
     }
-    async getFile(deviceFilePath, appIdentifier, outputFilePath) {
-        if (outputFilePath) {
-            await this.$iosDeviceOperations.downloadFiles([
+    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([
                 {
-                    appId: appIdentifier,
                     deviceId: this.device.deviceInfo.identifier,
-                    source: deviceFilePath,
-                    destination: outputFilePath,
+                    path: deviceFilePath,
+                    appId: appIdentifier,
                 },
             ]);
-            return;
-        }
-        const fileContent = await this.getFileContent(deviceFilePath, appIdentifier);
-        this.$logger.info(fileContent);
-    }
-    async getFileContent(deviceFilePath, appIdentifier) {
-        const result = await this.$iosDeviceOperations.readFiles([
-            {
-                deviceId: this.device.deviceInfo.identifier,
-                path: deviceFilePath,
-                appId: appIdentifier,
-            },
-        ]);
-        const response = result[this.device.deviceInfo.identifier][0];
-        return response.response;
+            const response = result[this.device.deviceInfo.identifier][0];
+            return response.response;
+        });
     }
-    async putFile(localFilePath, deviceFilePath, appIdentifier) {
-        await this.uploadFilesCore([
-            {
-                appId: appIdentifier,
-                deviceId: this.device.deviceInfo.identifier,
-                files: [{ source: localFilePath, destination: deviceFilePath }],
-            },
-        ]);
+    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 }],
+                },
+            ]);
+        });
     }
-    async deleteFile(deviceFilePath, appIdentifier) {
-        await 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}`);
-            }
+    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}`);
+                }
+            });
         });
     }
-    async transferFiles(deviceAppData, localToDevicePaths) {
-        const filesToUpload = _.filter(localToDevicePaths, (l) => this.$fs.getFsStats(l.getLocalPath()).isFile());
-        const files = filesToUpload.map((l) => ({
-            source: l.getLocalPath(),
-            destination: l.getDevicePath(),
-        }));
-        await this.uploadFilesCore([
-            {
-                deviceId: this.device.deviceInfo.identifier,
-                appId: deviceAppData.appIdentifier,
-                files: files,
-            },
-        ]);
-        return filesToUpload;
+    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;
+        });
     }
-    async transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
-        await this.transferFiles(deviceAppData, localToDevicePaths);
-        return localToDevicePaths;
+    transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transferFiles(deviceAppData, localToDevicePaths);
+            return localToDevicePaths;
+        });
     }
-    async updateHashesOnDevice(hashes, appIdentifier) {
-        return;
+    updateHashesOnDevice(hashes, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
     }
-    async uploadFilesCore(filesToUpload) {
-        await this.$iosDeviceOperations.uploadFiles(filesToUpload, (err) => {
-            if (err.deviceId === this.device.deviceInfo.identifier) {
-                throw err;
-            }
+    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;
+                }
+            });
         });
     }
 }
-exports.IOSDeviceFileSystem = IOSDeviceFileSystem;
 IOSDeviceFileSystem.AFC_DELETE_FILE_NOT_FOUND_ERROR = 8;
+exports.IOSDeviceFileSystem = IOSDeviceFileSystem;
+//# sourceMappingURL=ios-device-file-system.js.map