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

package/lib/common/mobile/android/logcat-helper.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.LogcatHelper = void 0;
 const byline = require("byline");
@@ -14,78 +23,87 @@ class LogcatHelper {
         this.$devicesService = $devicesService;
         this.mapDevicesLoggingData = Object.create(null);
     }
-    async start(options) {
-        const deviceIdentifier = options.deviceIdentifier;
-        if (deviceIdentifier && !this.mapDevicesLoggingData[deviceIdentifier]) {
-            this.mapDevicesLoggingData[deviceIdentifier] = {
-                loggingProcess: null,
-                lineStream: null,
-                keepSingleProcess: options.keepSingleProcess,
-                appStartTrackingProcess: null,
-                rawLineStream: null,
-            };
-            const logcatStream = await this.getLogcatStream(deviceIdentifier, options.pid);
-            const lineStream = byline(logcatStream.stdout);
-            this.mapDevicesLoggingData[deviceIdentifier].loggingProcess =
-                logcatStream;
-            this.mapDevicesLoggingData[deviceIdentifier].lineStream = lineStream;
-            logcatStream.stderr.on("data", (data) => {
-                this.$logger.trace("ADB logcat stderr: " + data.toString());
-            });
-            logcatStream.on("close", (code) => {
-                try {
-                    this.forceStop(deviceIdentifier);
-                    if (code !== 0) {
-                        this.$logger.trace("ADB process exited with code " + code.toString());
+    start(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceIdentifier = options.deviceIdentifier;
+            if (deviceIdentifier && !this.mapDevicesLoggingData[deviceIdentifier]) {
+                this.mapDevicesLoggingData[deviceIdentifier] = {
+                    loggingProcess: null,
+                    lineStream: null,
+                    keepSingleProcess: options.keepSingleProcess,
+                    appStartTrackingProcess: null,
+                    rawLineStream: null,
+                };
+                const logcatStream = yield this.getLogcatStream(deviceIdentifier, options.pid);
+                const lineStream = byline(logcatStream.stdout);
+                this.mapDevicesLoggingData[deviceIdentifier].loggingProcess =
+                    logcatStream;
+                this.mapDevicesLoggingData[deviceIdentifier].lineStream = lineStream;
+                logcatStream.stderr.on("data", (data) => {
+                    this.$logger.trace("ADB logcat stderr: " + data.toString());
+                });
+                logcatStream.on("close", (code) => {
+                    try {
+                        this.forceStop(deviceIdentifier);
+                        if (code !== 0) {
+                            this.$logger.trace("ADB process exited with code " + code.toString());
+                        }
+                    }
+                    catch (err) {
+                        // Ignore the error, the process is dead.
+                    }
+                });
+                lineStream.on("data", (lineBuffer) => {
+                    const lines = (lineBuffer.toString() || "").split("\n");
+                    for (const line of lines) {
+                        this.$deviceLogProvider.logData(line, this.$devicePlatformsConstants.Android, deviceIdentifier);
+                    }
+                });
+                const appStartTrackingStream = yield this.getAppStartTrackingLogcatStream(deviceIdentifier, options.appId);
+                this.mapDevicesLoggingData[deviceIdentifier].appStartTrackingProcess =
+                    appStartTrackingStream;
+                const rawLineStream = byline(appStartTrackingStream.stdout);
+                this.mapDevicesLoggingData[deviceIdentifier].rawLineStream =
+                    rawLineStream;
+                rawLineStream.on("data", (lineBuffer) => {
+                    var _a, _b, _c, _d;
+                    if (!((_a = this.mapDevicesLoggingData[deviceIdentifier]) === null || _a === void 0 ? void 0 : _a.loggingProcess))
+                        return;
+                    const lines = (lineBuffer.toString() || "").split("\n");
+                    for (let line of lines) {
+                        // 2024-06-26 16:43:22.286   630-659   ActivityManager system_server I  Start proc 8854:org.nativescript.uitestsapp/u0a190 for next-top-activity {org.nativescript.uitestsapp/com.tns.NativeScriptActivity}
+                        const startProc = /Start proc (?<pid>[0-9]+):(?<appId>.+?)\//.exec(line);
+                        if (startProc &&
+                            ((_b = startProc.groups) === null || _b === void 0 ? void 0 : _b.appId) === options.appId &&
+                            ((_c = startProc.groups) === null || _c === void 0 ? void 0 : _c.pid) !== options.pid) {
+                            this.forceStop(deviceIdentifier);
+                            (_d = options.onAppRestarted) === null || _d === void 0 ? void 0 : _d.call(options);
+                        }
                     }
-                }
-                catch (err) {
-                }
+                });
+            }
+        });
+    }
+    dump(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            const logcatDumpStream = yield adb.executeCommand(["logcat", "-d"], {
+                returnChildProcess: true,
             });
-            lineStream.on("data", (lineBuffer) => {
-                const lines = (lineBuffer.toString() || "").split("\n");
-                for (const line of lines) {
-                    this.$deviceLogProvider.logData(line, this.$devicePlatformsConstants.Android, deviceIdentifier);
-                }
+            const lineStream = byline(logcatDumpStream.stdout);
+            lineStream.on("data", (line) => {
+                const lineText = line.toString();
+                this.$logger.trace(lineText);
             });
-            const appStartTrackingStream = await this.getAppStartTrackingLogcatStream(deviceIdentifier, options.appId);
-            this.mapDevicesLoggingData[deviceIdentifier].appStartTrackingProcess =
-                appStartTrackingStream;
-            const rawLineStream = byline(appStartTrackingStream.stdout);
-            this.mapDevicesLoggingData[deviceIdentifier].rawLineStream =
-                rawLineStream;
-            rawLineStream.on("data", (lineBuffer) => {
-                var _a, _b, _c, _d;
-                if (!((_a = this.mapDevicesLoggingData[deviceIdentifier]) === null || _a === void 0 ? void 0 : _a.loggingProcess))
-                    return;
-                const lines = (lineBuffer.toString() || "").split("\n");
-                for (let line of lines) {
-                    const startProc = /Start proc (?<pid>[0-9]+):(?<appId>.+?)\//.exec(line);
-                    if (startProc &&
-                        ((_b = startProc.groups) === null || _b === void 0 ? void 0 : _b.appId) === options.appId &&
-                        ((_c = startProc.groups) === null || _c === void 0 ? void 0 : _c.pid) !== options.pid) {
-                        this.forceStop(deviceIdentifier);
-                        (_d = options.onAppRestarted) === null || _d === void 0 ? void 0 : _d.call(options);
-                    }
-                }
+            logcatDumpStream.on("close", (code) => {
+                logcatDumpStream.removeAllListeners();
+                lineStream.removeAllListeners();
             });
-        }
-    }
-    async dump(deviceIdentifier) {
-        const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
-        const logcatDumpStream = await adb.executeCommand(["logcat", "-d"], {
-            returnChildProcess: true,
-        });
-        const lineStream = byline(logcatDumpStream.stdout);
-        lineStream.on("data", (line) => {
-            const lineText = line.toString();
-            this.$logger.trace(lineText);
-        });
-        logcatDumpStream.on("close", (code) => {
-            logcatDumpStream.removeAllListeners();
-            lineStream.removeAllListeners();
         });
     }
+    /**
+     * Stops the logcat process for the specified device if keepSingleProcess is not passed on start
+     */
     stop(deviceIdentifier) {
         if (this.mapDevicesLoggingData[deviceIdentifier] &&
             !this.mapDevicesLoggingData[deviceIdentifier].keepSingleProcess) {
@@ -102,54 +120,68 @@ class LogcatHelper {
         (_e = loggingData.lineStream) === null || _e === void 0 ? void 0 : _e.removeAllListeners();
         delete this.mapDevicesLoggingData[deviceIdentifier];
     }
-    async isLogcatPidSupported(deviceIdentifier) {
-        const device = await this.$devicesService.getDevice(deviceIdentifier);
-        const minAndroidWithLogcatPidSupport = "7.0.0";
-        return (!!device.deviceInfo.version &&
-            semver.gte(semver.coerce(device.deviceInfo.version), minAndroidWithLogcatPidSupport));
+    /**
+     * @deprecated - we likely don't need this anymore, and can simplify the code...
+     */
+    isLogcatPidSupported(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.$devicesService.getDevice(deviceIdentifier);
+            const minAndroidWithLogcatPidSupport = "7.0.0";
+            return (!!device.deviceInfo.version &&
+                semver.gte(semver.coerce(device.deviceInfo.version), minAndroidWithLogcatPidSupport));
+        });
     }
-    async getLogcatStream(deviceIdentifier, pid) {
-        const isLogcatPidSupported = await this.isLogcatPidSupported(deviceIdentifier);
-        const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
-        const logcatCommand = ["logcat", "-T", "1"];
-        const acceptedTags = [
-            "chromium",
-            '"Web Console"',
-            "JS",
-            "System.err",
-            "TNS.Native",
-            "TNS.Java",
-        ];
-        if (pid && isLogcatPidSupported) {
-            logcatCommand.push(`--pid=${pid}`);
-            acceptedTags.forEach((tag) => {
-                logcatCommand.push("-s", tag);
+    getLogcatStream(deviceIdentifier, pid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isLogcatPidSupported = yield this.isLogcatPidSupported(deviceIdentifier);
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            // -T 1 - shows only new logs after starting adb logcat
+            const logcatCommand = ["logcat", "-T", "1"];
+            const acceptedTags = [
+                "chromium",
+                '"Web Console"',
+                "JS",
+                "System.err",
+                "TNS.Native",
+                "TNS.Java",
+            ];
+            if (pid && isLogcatPidSupported) {
+                logcatCommand.push(`--pid=${pid}`);
+                acceptedTags.forEach((tag) => {
+                    // -s <tag> - shows only logs with the specified tag
+                    logcatCommand.push("-s", tag);
+                });
+            }
+            const logcatStream = yield adb.executeCommand(logcatCommand, {
+                returnChildProcess: true,
             });
-        }
-        const logcatStream = await adb.executeCommand(logcatCommand, {
-            returnChildProcess: true,
+            return logcatStream;
         });
-        return logcatStream;
     }
-    async getAppStartTrackingLogcatStream(deviceIdentifier, appId) {
-        const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
-        const logcatCommand = [
-            `logcat`,
-            `-b`,
-            `system`,
-            `-T`,
-            `1`,
-            "-s",
-            "ActivityManager",
-        ];
-        if (appId) {
-            logcatCommand.push(`--regex=Start.*${appId}`);
-        }
-        const appStartTrackingStream = await adb.executeCommand(logcatCommand, {
-            returnChildProcess: true,
+    getAppStartTrackingLogcatStream(deviceIdentifier, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            // -b system  - shows the system buffer/logs only
+            // -T 1 			- shows only new logs after starting adb logcat
+            const logcatCommand = [
+                `logcat`,
+                `-b`,
+                `system`,
+                `-T`,
+                `1`,
+                "-s",
+                "ActivityManager",
+            ];
+            if (appId) {
+                logcatCommand.push(`--regex=Start.*${appId}`);
+            }
+            const appStartTrackingStream = yield adb.executeCommand(logcatCommand, {
+                returnChildProcess: true,
+            });
+            return appStartTrackingStream;
         });
-        return appStartTrackingStream;
     }
 }
 exports.LogcatHelper = LogcatHelper;
 yok_1.injector.register("logcatHelper", LogcatHelper);
+//# sourceMappingURL=logcat-helper.js.map

package/lib/common/mobile/application-manager-base.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.ApplicationManagerBase = void 0;
 const events_1 = require("events");
@@ -12,102 +21,122 @@ class ApplicationManagerBase extends events_1.EventEmitter {
         this.$deviceLogProvider = $deviceLogProvider;
         this.lastAvailableDebuggableAppViews = {};
     }
-    async setTransferredAppFiles(files) {
-        for (const file of files) {
-            await this.$deviceLogProvider.setSourceFileLocation(file);
-        }
+    setTransferredAppFiles(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const file of files) {
+                yield this.$deviceLogProvider.setSourceFileLocation(file);
+            }
+        });
     }
-    async reinstallApplication(appIdentifier, packageFilePath, buildData) {
-        const isApplicationInstalled = await this.isApplicationInstalled(appIdentifier);
-        if (isApplicationInstalled && (buildData === null || buildData === void 0 ? void 0 : buildData.clean)) {
-            await this.uninstallApplication(appIdentifier);
-        }
-        await this.installApplication(packageFilePath, appIdentifier, buildData);
+    reinstallApplication(appIdentifier, packageFilePath, buildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isApplicationInstalled = yield this.isApplicationInstalled(appIdentifier);
+            if (isApplicationInstalled && (buildData === null || buildData === void 0 ? void 0 : buildData.clean)) {
+                yield this.uninstallApplication(appIdentifier);
+            }
+            yield this.installApplication(packageFilePath, appIdentifier, buildData);
+        });
     }
-    async restartApplication(appData) {
-        await this.stopApplication(appData);
-        await this.startApplication(appData);
+    restartApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stopApplication(appData);
+            yield this.startApplication(appData);
+        });
     }
-    async isApplicationInstalled(appIdentifier) {
-        await this.checkForApplicationUpdates();
-        return _.includes(this.lastInstalledAppIdentifiers, appIdentifier);
+    isApplicationInstalled(appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.checkForApplicationUpdates();
+            return _.includes(this.lastInstalledAppIdentifiers, appIdentifier);
+        });
     }
-    async checkForApplicationUpdates() {
-        if (!this.checkForApplicationUpdatesPromise) {
-            this.checkForApplicationUpdatesPromise = new Promise(async (resolve, reject) => {
-                let isFulfilled = false;
-                try {
-                    const currentlyInstalledAppIdentifiers = await this.getInstalledApplications();
-                    const previouslyInstalledAppIdentifiers = this.lastInstalledAppIdentifiers || [];
-                    const newAppIdentifiers = _.difference(currentlyInstalledAppIdentifiers, previouslyInstalledAppIdentifiers);
-                    const removedAppIdentifiers = _.difference(previouslyInstalledAppIdentifiers, currentlyInstalledAppIdentifiers);
-                    this.lastInstalledAppIdentifiers = currentlyInstalledAppIdentifiers;
-                    _.each(newAppIdentifiers, (appIdentifier) => this.emit("applicationInstalled", appIdentifier));
-                    _.each(removedAppIdentifiers, (appIdentifier) => this.emit("applicationUninstalled", appIdentifier));
-                    await this.checkForAvailableDebuggableAppsChanges();
-                }
-                catch (err) {
-                    isFulfilled = true;
-                    reject(err);
-                }
-                finally {
-                    this.checkForApplicationUpdatesPromise = null;
-                    if (!isFulfilled) {
-                        resolve();
+    checkForApplicationUpdates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.checkForApplicationUpdatesPromise) {
+                this.checkForApplicationUpdatesPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                    let isFulfilled = false;
+                    // As this method is called on 500ms, but it's execution may last much longer
+                    // use locking, so the next executions will not get into the body, while the first one is still working.
+                    // In case we do not break the next executions, we'll report each app as newly installed several times.
+                    try {
+                        const currentlyInstalledAppIdentifiers = yield this.getInstalledApplications();
+                        const previouslyInstalledAppIdentifiers = this.lastInstalledAppIdentifiers || [];
+                        const newAppIdentifiers = _.difference(currentlyInstalledAppIdentifiers, previouslyInstalledAppIdentifiers);
+                        const removedAppIdentifiers = _.difference(previouslyInstalledAppIdentifiers, currentlyInstalledAppIdentifiers);
+                        this.lastInstalledAppIdentifiers = currentlyInstalledAppIdentifiers;
+                        _.each(newAppIdentifiers, (appIdentifier) => this.emit("applicationInstalled", appIdentifier));
+                        _.each(removedAppIdentifiers, (appIdentifier) => this.emit("applicationUninstalled", appIdentifier));
+                        yield this.checkForAvailableDebuggableAppsChanges();
                     }
-                }
-            });
-        }
-        return this.checkForApplicationUpdatesPromise;
-    }
-    async tryStartApplication(appData) {
-        try {
-            await this.startApplication(appData);
-        }
-        catch (err) {
-            this.$logger.trace(`Unable to start application ${appData.appId} with name ${appData.projectName}. Error is: ${err.message}`);
-        }
-    }
-    async checkForAvailableDebuggableAppsChanges() {
-        const currentlyAvailableDebuggableApps = await this.getDebuggableApps();
-        const previouslyAvailableDebuggableApps = this.lastAvailableDebuggableApps || [];
-        const newAvailableDebuggableApps = _.differenceBy(currentlyAvailableDebuggableApps, previouslyAvailableDebuggableApps, "appIdentifier");
-        const notAvailableAppsForDebugging = _.differenceBy(previouslyAvailableDebuggableApps, currentlyAvailableDebuggableApps, "appIdentifier");
-        this.lastAvailableDebuggableApps = currentlyAvailableDebuggableApps;
-        _.each(newAvailableDebuggableApps, (appInfo) => {
-            this.emit("debuggableAppFound", appInfo);
+                    catch (err) {
+                        isFulfilled = true;
+                        reject(err);
+                    }
+                    finally {
+                        this.checkForApplicationUpdatesPromise = null;
+                        if (!isFulfilled) {
+                            resolve();
+                        }
+                    }
+                }));
+            }
+            return this.checkForApplicationUpdatesPromise;
         });
-        _.each(notAvailableAppsForDebugging, (appInfo) => {
-            this.emit("debuggableAppLost", appInfo);
-            if (_.has(this.lastAvailableDebuggableAppViews, appInfo.appIdentifier)) {
-                delete this.lastAvailableDebuggableAppViews[appInfo.appIdentifier];
+    }
+    tryStartApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.startApplication(appData);
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to start application ${appData.appId} with name ${appData.projectName}. Error is: ${err.message}`);
             }
         });
-        const cordovaDebuggableAppIdentifiers = _(currentlyAvailableDebuggableApps)
-            .filter((c) => c.framework === constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova)
-            .map((c) => c.appIdentifier)
-            .value();
-        const currentlyAvailableAppViews = await this.getDebuggableAppViews(cordovaDebuggableAppIdentifiers);
-        _.each(currentlyAvailableAppViews, (currentlyAvailableViews, appIdentifier) => {
-            const previouslyAvailableViews = this.lastAvailableDebuggableAppViews[appIdentifier];
-            const newAvailableViews = _.differenceBy(currentlyAvailableViews, previouslyAvailableViews, "id");
-            const notAvailableViews = _.differenceBy(previouslyAvailableViews, currentlyAvailableViews, "id");
-            _.each(notAvailableViews, (debugWebViewInfo) => {
-                this.emit("debuggableViewLost", appIdentifier, debugWebViewInfo);
-            });
-            _.each(newAvailableViews, (debugWebViewInfo) => {
-                this.emit("debuggableViewFound", appIdentifier, debugWebViewInfo);
+    }
+    checkForAvailableDebuggableAppsChanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentlyAvailableDebuggableApps = yield this.getDebuggableApps();
+            const previouslyAvailableDebuggableApps = this.lastAvailableDebuggableApps || [];
+            const newAvailableDebuggableApps = _.differenceBy(currentlyAvailableDebuggableApps, previouslyAvailableDebuggableApps, "appIdentifier");
+            const notAvailableAppsForDebugging = _.differenceBy(previouslyAvailableDebuggableApps, currentlyAvailableDebuggableApps, "appIdentifier");
+            this.lastAvailableDebuggableApps = currentlyAvailableDebuggableApps;
+            _.each(newAvailableDebuggableApps, (appInfo) => {
+                this.emit("debuggableAppFound", appInfo);
             });
-            const keptViews = _.differenceBy(currentlyAvailableViews, newAvailableViews, "id");
-            _.each(keptViews, (view) => {
-                const previousTimeViewInfo = _.find(previouslyAvailableViews, (previousView) => previousView.id === view.id);
-                if (!_.isEqual(view, previousTimeViewInfo)) {
-                    this.emit("debuggableViewChanged", appIdentifier, view);
+            _.each(notAvailableAppsForDebugging, (appInfo) => {
+                this.emit("debuggableAppLost", appInfo);
+                if (_.has(this.lastAvailableDebuggableAppViews, appInfo.appIdentifier)) {
+                    // Prevent emitting debuggableViewLost when application cannot be debugged anymore.
+                    delete this.lastAvailableDebuggableAppViews[appInfo.appIdentifier];
                 }
             });
-            this.lastAvailableDebuggableAppViews[appIdentifier] =
-                currentlyAvailableViews;
+            const cordovaDebuggableAppIdentifiers = _(currentlyAvailableDebuggableApps)
+                .filter((c) => c.framework === constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova)
+                .map((c) => c.appIdentifier)
+                .value();
+            const currentlyAvailableAppViews = yield this.getDebuggableAppViews(cordovaDebuggableAppIdentifiers);
+            _.each(currentlyAvailableAppViews, (currentlyAvailableViews, appIdentifier) => {
+                const previouslyAvailableViews = this.lastAvailableDebuggableAppViews[appIdentifier];
+                const newAvailableViews = _.differenceBy(currentlyAvailableViews, previouslyAvailableViews, "id");
+                const notAvailableViews = _.differenceBy(previouslyAvailableViews, currentlyAvailableViews, "id");
+                _.each(notAvailableViews, (debugWebViewInfo) => {
+                    this.emit("debuggableViewLost", appIdentifier, debugWebViewInfo);
+                });
+                _.each(newAvailableViews, (debugWebViewInfo) => {
+                    this.emit("debuggableViewFound", appIdentifier, debugWebViewInfo);
+                });
+                // Determine which of the views had changed since last check and raise debuggableViewChanged event for them:
+                const keptViews = _.differenceBy(currentlyAvailableViews, newAvailableViews, "id");
+                _.each(keptViews, (view) => {
+                    const previousTimeViewInfo = _.find(previouslyAvailableViews, (previousView) => previousView.id === view.id);
+                    if (!_.isEqual(view, previousTimeViewInfo)) {
+                        this.emit("debuggableViewChanged", appIdentifier, view);
+                    }
+                });
+                this.lastAvailableDebuggableAppViews[appIdentifier] =
+                    currentlyAvailableViews;
+            });
         });
     }
 }
 exports.ApplicationManagerBase = ApplicationManagerBase;
+//# sourceMappingURL=application-manager-base.js.map

package/lib/common/mobile/device-emitter.js

@@ -15,7 +15,10 @@ class DeviceEmitter extends events_1.EventEmitter {
         this.$devicesService.on(constants_1.DeviceDiscoveryEventNames.DEVICE_FOUND, (device) => {
             this.emit(constants_1.DeviceDiscoveryEventNames.DEVICE_FOUND, device.deviceInfo);
             this.attachApplicationChangedHandlers(device);
+            // await: Do not await as this will require to mark the lambda with async keyword, but there's no way to await the lambda itself.
+            /* tslint:disable:no-floating-promises */
             device.openDeviceLogStream();
+            /* tslint:enable:no-floating-promises */
         });
         this.$devicesService.on(constants_1.DeviceDiscoveryEventNames.DEVICE_LOST, (device) => {
             this.emit(constants_1.DeviceDiscoveryEventNames.DEVICE_LOST, device.deviceInfo);
@@ -59,3 +62,4 @@ class DeviceEmitter extends events_1.EventEmitter {
 }
 exports.DeviceEmitter = DeviceEmitter;
 yok_1.injector.register("deviceEmitter", DeviceEmitter);
+//# sourceMappingURL=device-emitter.js.map

package/lib/common/mobile/device-log-emitter.js

@@ -38,3 +38,4 @@ class DeviceLogEmitter extends device_log_provider_base_1.DeviceLogProviderBase
 }
 exports.DeviceLogEmitter = DeviceLogEmitter;
 yok_1.injector.register("deviceLogProvider", DeviceLogEmitter);
+//# sourceMappingURL=device-log-emitter.js.map

package/lib/common/mobile/device-log-provider-base.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.DeviceLogProviderBase = void 0;
 const events_1 = require("events");
@@ -11,13 +20,15 @@ class DeviceLogProviderBase extends events_1.EventEmitter {
         this.$logSourceMapService = $logSourceMapService;
         this.devicesLogOptions = {};
     }
-    async setSourceFileLocation(pathToOriginalFile) {
-        try {
-            await this.$logSourceMapService.setSourceMapConsumerForFile(pathToOriginalFile);
-        }
-        catch (err) {
-            this.$logger.trace("Error while trying to set source map file", err);
-        }
+    setSourceFileLocation(pathToOriginalFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.$logSourceMapService.setSourceMapConsumerForFile(pathToOriginalFile);
+            }
+            catch (err) {
+                this.$logger.trace("Error while trying to set source map file", err);
+            }
+        });
     }
     setApplicationPidForDevice(deviceIdentifier, pid) {
         this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.applicationPid, pid);
@@ -63,3 +74,4 @@ class DeviceLogProviderBase extends events_1.EventEmitter {
     }
 }
 exports.DeviceLogProviderBase = DeviceLogProviderBase;
+//# sourceMappingURL=device-log-provider-base.js.map

package/lib/common/mobile/device-log-provider.js

@@ -36,6 +36,7 @@ class DeviceLogProvider extends device_log_provider_base_1.DeviceLogProviderBase
         this.colorPoolIndex = 0;
     }
     logData(lineText, platform, deviceIdentifier) {
+        // console.log(lineText)
         const loggingOptions = this.getDeviceLogOptionsForDevice(deviceIdentifier);
         let data = this.$logFilter.filterData(platform, lineText, loggingOptions);
         data = this.$logSourceMapService.replaceWithOriginalFileLocations(platform, data, loggingOptions);
@@ -53,6 +54,7 @@ class DeviceLogProvider extends device_log_provider_base_1.DeviceLogProviderBase
             return this.deviceColorMap.get(deviceIdentifier);
         }
         const color = this.colorPool[this.colorPoolIndex];
+        // wrap around if we have no more colors in the pool
         this.colorPoolIndex =
             this.colorPoolIndex === this.colorPool.length - 1
                 ? 0
@@ -62,10 +64,13 @@ class DeviceLogProvider extends device_log_provider_base_1.DeviceLogProviderBase
     }
     logDataCore(data, deviceIdentifier) {
         var _a, _b, _c;
+        // todo: use config to set logger - --env.classicLogs is temporary!
         if ("classicLogs" in ((_a = this.$options.env) !== null && _a !== void 0 ? _a : {})) {
+            // legacy logging
             this.$logger.info(data, { [constants_2.LoggerConfigData.skipNewLine]: true });
             return;
         }
+        // todo: extract into an injectable printer/logger service
         let shouldPrepend = false;
         let splitIndexes = [];
         const lines = data
@@ -120,7 +125,25 @@ class DeviceLogProvider extends device_log_provider_base_1.DeviceLogProviderBase
     printLine(prefix, ...parts) {
         const fullLine = parts.join(" ");
         console.log(prefix, fullLine);
+        /**
+         * Note: Disabled
+         *
+         * This splits the output into lines that fit within the current
+         * terminal width, however this makes copying json objects that
+         * span across multiple lines difficult, as it introduces
+         * whitespace & line breaks
+         */
+        // const maxWidth = process.stdout.columns - 2;
+        // if (!maxWidth || maxWidth < 10 || fullLine.length < maxWidth) {
+        // 	console.log(prefix, fullLine);
+        // } else {
+        // 	for (let i = 0; i < fullLine.length; i += maxWidth) {
+        // 		const part = fullLine.substring(i, i + maxWidth);
+        // 		console.log(prefix, part);
+        // 	}
+        // }
     }
 }
 exports.DeviceLogProvider = DeviceLogProvider;
 yok_1.injector.register("deviceLogProvider", DeviceLogProvider);
+//# sourceMappingURL=device-log-provider.js.map

package/lib/common/mobile/device-platforms-constants.js

@@ -20,3 +20,4 @@ class DevicePlatformsConstants {
 }
 exports.DevicePlatformsConstants = DevicePlatformsConstants;
 yok_1.injector.register("devicePlatformsConstants", DevicePlatformsConstants);
+//# sourceMappingURL=device-platforms-constants.js.map