nativescript 9.1.0-alpha.1 → 9.1.0-alpha.10

package/lib/commands/prepare.js

@@ -22,6 +22,11 @@ class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
                 hasSensitiveValue: false,
             },
             hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
+            skipNative: {
+                type: "boolean" /* OptionType.Boolean */,
+                default: false,
+                hasSensitiveValue: false,
+            },
             whatever: {
                 type: "boolean" /* OptionType.Boolean */,
                 default: false,

package/lib/common/definitions/mobile.d.ts

@@ -258,8 +258,7 @@ declare global {
 		 * Describes different options for filtering device logs.
 		 */
 		interface IDeviceLogOptions
-			extends IDictionary<string | boolean>,
-				Partial<IProjectDir> {
+			extends IDictionary<string | boolean>, Partial<IProjectDir> {
 			/**
 			 * Process id of the application on the device.
 			 */
@@ -284,8 +283,7 @@ declare global {
 		 * Describes required methods for getting iOS Simulator's logs.
 		 */
 		interface IiOSSimulatorLogProvider
-			extends NodeJS.EventEmitter,
-				IShouldDispose {
+			extends NodeJS.EventEmitter, IShouldDispose {
 			/**
 			 * Starts the process for getting simulator logs and emits and DEVICE_LOG_EVENT_NAME event.
 			 * @param {string} deviceId The unique identifier of the device.
@@ -429,6 +427,16 @@ declare global {
 
 		interface IDeviceFileSystem {
 			listFiles(devicePath: string, appIdentifier?: string): Promise<any>;
+			/**
+			 * Returns the entries of a directory inside the application's
+			 * sandbox, or null when the directory cannot be read. Currently
+			 * implemented only for physical iOS devices (AFC), where it backs
+			 * the post-transfer livesync verification.
+			 */
+			getDirectoryEntries?(
+				devicePath: string,
+				appIdentifier: string,
+			): Promise<string[] | null>;
 			getFile(
 				deviceFilePath: string,
 				appIdentifier: string,
@@ -533,8 +541,7 @@ declare global {
 		/**
 		 * Describes options that can be passed to devices service's initialization method.
 		 */
-		interface IDevicesServicesInitializationOptions
-			extends Partial<IDeviceLookingOptions> {
+		interface IDevicesServicesInitializationOptions extends Partial<IDeviceLookingOptions> {
 			/**
 			 * If passed will start an emulator if necesasry.
 			 */
@@ -1261,8 +1268,7 @@ declare global {
 		}
 
 		interface IDeviceLookingOptions
-			extends IHasEmulatorOption,
-				IHasDetectionInterval {
+			extends IHasEmulatorOption, IHasDetectionInterval {
 			shouldReturnImmediateResult: boolean;
 			platform: string;
 			fullDiscovery?: boolean;
@@ -1388,8 +1394,7 @@ declare global {
 		/**
 		 * Describes information about application on device.
 		 */
-		interface IDeviceApplicationInformation
-			extends IDeviceApplicationInformationBase {
+		interface IDeviceApplicationInformation extends IDeviceApplicationInformationBase {
 			/**
 			 * The framework of the project (Cordova or NativeScript).
 			 */

package/lib/common/mobile/android/android-emulator-services.js

@@ -9,7 +9,7 @@ const constants_2 = require("../../../constants");
 const yok_1 = require("../../yok");
 const semver = require("semver");
 class AndroidEmulatorServices {
-    constructor($androidGenymotionService, $androidVirtualDeviceService, $adb, $childProcess, $emulatorHelper, $logger, $utils) {
+    constructor($androidGenymotionService, $androidVirtualDeviceService, $adb, $childProcess, $emulatorHelper, $logger, $utils, $userSettingsService) {
         this.$androidGenymotionService = $androidGenymotionService;
         this.$androidVirtualDeviceService = $androidVirtualDeviceService;
         this.$adb = $adb;
@@ -17,6 +17,7 @@ class AndroidEmulatorServices {
         this.$emulatorHelper = $emulatorHelper;
         this.$logger = $logger;
         this.$utils = $utils;
+        this.$userSettingsService = $userSettingsService;
     }
     async getEmulatorImages() {
         const adbDevicesOutput = await this.$adb.getDevicesSafe();
@@ -90,7 +91,7 @@ class AndroidEmulatorServices {
                 endTimeEpoch,
             };
         }
-        this.spawnEmulator(emulator);
+        await this.spawnEmulator(emulator);
         const isInfiniteWait = this.$utils.getMilliSecondsTimeout(timeout) === 0;
         let hasTimeLeft = (0, helpers_1.getCurrentEpochTime)() < endTimeEpoch;
         while (hasTimeLeft || isInfiniteWait) {
@@ -114,13 +115,20 @@ class AndroidEmulatorServices {
             };
         }
     }
-    spawnEmulator(emulator) {
+    async spawnEmulator(emulator) {
         let pathToEmulatorExecutable = null;
         let startEmulatorArgs = null;
         if (emulator.vendor === constants_1.AndroidVirtualDevice.AVD_VENDOR_NAME) {
             pathToEmulatorExecutable =
                 this.$androidVirtualDeviceService.pathToEmulatorExecutable;
             startEmulatorArgs = this.$androidVirtualDeviceService.startEmulatorArgs(emulator.imageIdentifier);
+            try {
+                const additionalArgs = await this.$userSettingsService.getSettingValue("androidEmulatorStartArgs");
+                if (additionalArgs === null || additionalArgs === void 0 ? void 0 : additionalArgs.length) {
+                    startEmulatorArgs.push(...additionalArgs);
+                }
+            }
+            catch (error) { }
         }
         else if (emulator.vendor === constants_1.AndroidVirtualDevice.GENYMOTION_VENDOR_NAME) {
             pathToEmulatorExecutable =

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

@@ -9,6 +9,7 @@ class EmulatorHelper {
         // https://developer.android.com/guide/topics/manifest/uses-sdk-element
         this.mapAndroidApiLevelToVersion = {
             "android-36": "16.0.0",
+            "android-36.1": "16.0.0",
             "android-35": "15.0.0",
             "android-34": "14.0.0",
             "android-33": "13.0.0",

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

@@ -23,6 +23,24 @@ class IOSDeviceFileSystem {
         children = result[deviceIdentifier][0].response;
         this.$logger.info(children.join(os_1.EOL));
     }
+    async getDirectoryEntries(devicePath, appIdentifier) {
+        var _a, _b;
+        try {
+            const result = await this.$iosDeviceOperations.listDirectory([
+                {
+                    deviceId: this.device.deviceInfo.identifier,
+                    path: devicePath,
+                    appId: appIdentifier,
+                },
+            ]);
+            const entries = (_b = (_a = result === null || result === void 0 ? void 0 : result[this.device.deviceInfo.identifier]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.response;
+            return Array.isArray(entries) ? entries : null;
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to list directory '${devicePath}' for application ${appIdentifier}: ${err.message}`);
+            return null;
+        }
+    }
     async getFile(deviceFilePath, appIdentifier, outputFilePath) {
         if (outputFilePath) {
             await this.$iosDeviceOperations.downloadFiles([
@@ -96,9 +114,19 @@ class IOSDeviceFileSystem {
     }
     async uploadFilesCore(filesToUpload) {
         await this.$iosDeviceOperations.uploadFiles(filesToUpload, (err) => {
-            if (err.deviceId === this.device.deviceInfo.identifier) {
+            // Previously an error whose deviceId did not exactly match was
+            // dropped on the floor — including errors with NO deviceId at
+            // all (some ios-device-lib error paths don't attribute one).
+            // That left "Successfully synced" printed over a failed
+            // transfer and the app silently running stale JavaScript.
+            // Rethrow unless the error is positively attributed to a
+            // DIFFERENT device; surface even those at warn level so a
+            // failed upload is never invisible.
+            if (!err.deviceId ||
+                err.deviceId === this.device.deviceInfo.identifier) {
                 throw err;
             }
+            this.$logger.warn(`File upload error reported for another device (${err.deviceId}): ${err.message}`);
         });
     }
 }

package/lib/controllers/prepare-controller.js

@@ -15,6 +15,7 @@ const decorators_1 = require("../common/decorators");
 const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
 const constants_1 = require("../constants");
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
 class PrepareController extends events_1.EventEmitter {
     constructor($platformController, $hooksService, $fs, $logger, $options, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $bundlerCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
         super();
@@ -229,28 +230,69 @@ class PrepareController extends events_1.EventEmitter {
      * TODO: move this logic to the webpack side of things - WIP and deprecate here with a webpack version check...
      */
     async writeRuntimePackageJson(projectData, platformData, prepareData = null) {
+        var _a, _b, _c, _d, _e;
         const configInfo = this.$projectConfigService.detectProjectConfigs(projectData.projectDir);
         if (configInfo.usingNSConfig) {
             return;
         }
         this.$logger.info("Updating runtime package.json with configuration values...");
-        const nsConfig = this.$projectConfigService.readConfig(projectData.projectDir);
+        // Tolerate a missing/unreadable config — prior to the destructure this
+        // was a plain object spread, where `undefined` is a legal no-op.
+        const { hooks, ignoredNativeDependencies, webpackPackageName, webpackConfigPath, appResourcesPath, buildPath, appPath, ...nsConfig } = (_a = this.$projectConfigService.readConfig(projectData.projectDir)) !== null && _a !== void 0 ? _a : {};
+        const platform = platformData.platformNameLowerCase;
+        let installedRuntimePackageJSON;
+        let runtimePackageName;
+        if (platform === "ios" /* PlatformTypes.ios */) {
+            runtimePackageName =
+                ((_c = (_b = projectData.nsConfig) === null || _b === void 0 ? void 0 : _b.ios) === null || _c === void 0 ? void 0 : _c.runtimePackageName) ||
+                    constants_1.SCOPED_IOS_RUNTIME_NAME;
+        }
+        else if (platform === "android" /* PlatformTypes.android */) {
+            runtimePackageName =
+                ((_e = (_d = projectData.nsConfig) === null || _d === void 0 ? void 0 : _d.android) === null || _e === void 0 ? void 0 : _e.runtimePackageName) ||
+                    constants_1.SCOPED_ANDROID_RUNTIME_NAME;
+        }
+        // try reading from installed runtime first before reading from the npm registry...
+        const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(runtimePackageName, {
+            paths: [projectData.projectDir],
+        });
+        if (installedRuntimePackageJSONPath) {
+            installedRuntimePackageJSON = this.$fs.readJson(installedRuntimePackageJSONPath);
+        }
         const packageData = {
             ..._.pick(projectData.packageJsonData, ["name"]),
             ...nsConfig,
             main: "bundle",
+            ...(installedRuntimePackageJSON ? {} : {}),
         };
-        if (platformData.platformNameLowerCase === "ios" &&
-            packageData.ios &&
-            packageData.ios.discardUncaughtJsExceptions) {
-            packageData.discardUncaughtJsExceptions =
-                packageData.ios.discardUncaughtJsExceptions;
+        if (platform === "ios" /* PlatformTypes.ios */) {
+            if (installedRuntimePackageJSON) {
+                packageData.ios = packageData.ios || {};
+                packageData.ios.runtime = {
+                    version: installedRuntimePackageJSON.version,
+                };
+            }
+            if (packageData.ios && packageData.ios.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.ios.discardUncaughtJsExceptions;
+            }
+            delete packageData.android;
         }
-        if (platformData.platformNameLowerCase === "android" &&
-            packageData.android &&
-            packageData.android.discardUncaughtJsExceptions) {
-            packageData.discardUncaughtJsExceptions =
-                packageData.android.discardUncaughtJsExceptions;
+        if (platform === "android" /* PlatformTypes.android */) {
+            if (installedRuntimePackageJSON) {
+                packageData.android = packageData.android || {};
+                packageData.android.runtime = {
+                    version: installedRuntimePackageJSON.version,
+                    version_info: installedRuntimePackageJSON.version_info,
+                    gradle: installedRuntimePackageJSON.gradle,
+                };
+            }
+            if (packageData.android &&
+                packageData.android.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.android.discardUncaughtJsExceptions;
+            }
+            delete packageData.ios;
         }
         let packagePath;
         if (this.$mobileHelper.isApplePlatform(platformData.platformNameLowerCase)) {

package/lib/controllers/run-controller.js

@@ -15,7 +15,7 @@ const util = require("util");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class RunController extends events_1.EventEmitter {
-    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService) {
+    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $staticConfig) {
         super();
         this.$analyticsService = $analyticsService;
         this.$buildController = $buildController;
@@ -37,7 +37,10 @@ class RunController extends events_1.EventEmitter {
         this.$prepareNativePlatformService = $prepareNativePlatformService;
         this.$projectChangesService = $projectChangesService;
         this.$projectDataService = $projectDataService;
+        this.$staticConfig = $staticConfig;
         this.prepareReadyEventHandler = null;
+        this._syncInProgress = false;
+        this._pendingSyncs = new Map();
     }
     async run(runData) {
         const { liveSyncInfo, deviceDescriptors } = runData;
@@ -60,13 +63,11 @@ class RunController extends events_1.EventEmitter {
                     const platformData = this.$platformsDataService.getPlatformData(data.platform, projectData);
                     const prepareData = this.$prepareDataService.getPrepareData(liveSyncInfo.projectDir, data.platform, { ...liveSyncInfo, watch: !liveSyncInfo.skipWatcher });
                     const changesInfo = await this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
-                    if (changesInfo.hasChanges) {
-                        await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+                    if (!changesInfo.hasChanges) {
+                        return;
                     }
                 }
-                else {
-                    await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
-                }
+                this.scheduleSyncOnDevices(data, projectData, liveSyncInfo);
             };
             this.prepareReadyEventHandler = handler.bind(this);
             this.$prepareController.on(constants_2.PREPARE_READY_EVENT_NAME, this.prepareReadyEventHandler);
@@ -277,6 +278,14 @@ class RunController extends events_1.EventEmitter {
                 },
                 watch: !liveSyncInfo.skipWatcher,
             });
+            // For Android + Vite HMR, own the `adb reverse` ourselves —
+            // with our SDK-resolved adb, scoped to this exact serial, and
+            // only after the device is up — then hand the bundler the
+            // result via env vars. This MUST run before `prepare` (which
+            // spawns the Vite bundler that inherits `process.env`) so the
+            // bundler trusts the tunnel instead of racing us to spawn its
+            // own adb during config-load. See packages/vite hardening.
+            await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-build");
             const prepareResultData = await this.$prepareController.prepare(prepareData);
             const buildData = {
                 ...deviceDescriptor.buildData,
@@ -327,6 +336,11 @@ class RunController extends events_1.EventEmitter {
                     watch: !skipWatcher,
                     liveSyncDeviceData: deviceDescriptor,
                 });
+                // Re-establish the adb reverse on the CURRENT transport right
+                // before launch — the transport can change during build/install
+                // and drop the mapping set in `pre-build`, which would leave the
+                // app unable to reach the Vite dev server at 127.0.0.1.
+                await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-launch");
                 await this.refreshApplication(projectData, liveSyncResultInfo, null, deviceDescriptor);
                 this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStarted, {
@@ -353,6 +367,134 @@ class RunController extends events_1.EventEmitter {
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => _.some(deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier)));
     }
+    /**
+     * Set up `adb reverse tcp:<port> tcp:<port>` for an Android device
+     * when the project bundles with Vite in HMR/watch mode, then export
+     * the result to the bundler subprocess via environment variables.
+     *
+     * The Vite dev-host helper prefers an ADB tunnel (device-side
+     * `127.0.0.1:<port>` → host) over the emulator's flaky slirp NAT
+     * (`10.0.2.2`). Historically the bundler tried to wire that tunnel
+     * itself at config-load time, racing this CLI's device discovery
+     * over the single global adb daemon and intermittently freezing the
+     * run at "Searching for devices…". The CLI is the right owner: it
+     * knows the exact target serial and when the device is ready, and it
+     * already drives a single, version-matched adb. We do the reverse
+     * here and signal the bundler with `NS_ADB_REVERSE_READY=1` so it
+     * never spawns adb on its own.
+     *
+     * Best-effort: any failure is logged at trace level and swallowed.
+     * The bundler then falls back to its own (now hardened) adb path, or
+     * ultimately to `10.0.2.2`, so a reverse hiccup never fails the run.
+     */
+    async setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, phase) {
+        try {
+            if (!this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+                return;
+            }
+            if (projectData.bundler !== "vite") {
+                return;
+            }
+            // HMR over the tunnel only matters for a live watch session.
+            if (liveSyncInfo.skipWatcher || !liveSyncInfo.useHotModuleReload) {
+                return;
+            }
+            // Respect the user's explicit opt-out — they want the
+            // `10.0.2.2` / LAN path, so don't create a tunnel or claim one
+            // exists.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_NO_ADB_REVERSE)) {
+                return;
+            }
+            // `NS_HMR_PREFER_LAN_HOST` means the dev wants LAN routing
+            // (physical device over Wi-Fi); the dev-host resolver suppresses
+            // the adb-reverse path for it, so don't bother wiring one.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_PREFER_LAN_HOST)) {
+                return;
+            }
+            const serial = device.deviceInfo.identifier;
+            const port = this.getViteHmrPort();
+            if (phase === "pre-build") {
+                // Decide the origin baked into bundle.mjs. Hand the bundler our
+                // exact adb (so any self-managed fallback can't version-mismatch
+                // the daemon) and, if the tunnel comes up, tell it to emit
+                // `127.0.0.1` and skip adb entirely.
+                process.env.NS_ADB_PATH = await this.$staticConfig.getAdbFilePath();
+                process.env.NS_DEVICE_SERIAL = serial;
+                const ok = await this.ensureAndroidReverse(device, serial, port);
+                if (ok) {
+                    process.env.NS_ADB_REVERSE_READY = "1";
+                    this.$logger.info(`Set up adb reverse tcp:${port} tcp:${port} for ${serial} (Vite HMR routes device-side 127.0.0.1:${port} through ADB).`);
+                }
+                else {
+                    this.$logger.warn(`Could not confirm 'adb reverse tcp:${port}' on ${serial} (device adbd slow/unresponsive). Vite HMR will fall back to 10.0.2.2. If this persists, cold-boot/wipe the emulator, or set NS_HMR_NO_ADB_REVERSE=1.`);
+                }
+                return;
+            }
+            // phase === "pre-launch": re-establish the mapping right before the
+            // app boots. `adb reverse` mappings are bound to the device's adb
+            // transport, and that transport can change during the (long) build
+            // + install (fresh emulators reconnect as they settle), silently
+            // dropping the early mapping. We only bother when we actually told
+            // the bundle to use `127.0.0.1` (READY set during pre-build).
+            if (!this.isTruthyEnvFlag(process.env.NS_ADB_REVERSE_READY)) {
+                return;
+            }
+            const ok = await this.ensureAndroidReverse(device, serial, port);
+            if (!ok) {
+                this.$logger.warn(`adb reverse tcp:${port} was not active before launch on ${serial}; the app may fail to reach the Vite dev server at 127.0.0.1:${port}.`);
+            }
+        }
+        catch (err) {
+            this.$logger.trace(`Setting up adb reverse for Vite HMR (${phase}) failed; leaving it to the bundler fallback. Error: ${err}`);
+        }
+    }
+    /**
+     * Apply `adb reverse tcp:<port> tcp:<port>` to the device and confirm
+     * via `adb reverse --list` that it actually landed, retrying a few
+     * times. Every device-side call is bounded with a Node `spawn` timeout
+     * + `SIGKILL` so a wedged/slow adbd (observed blocking 90s+ on some
+     * fresh-boot / API-36 arm64 emulators) can never hang the run — the
+     * hung adb child is reaped, not orphaned. Returns whether the mapping
+     * is confirmed present.
+     */
+    async ensureAndroidReverse(device, serial, port) {
+        var _a, _b, _c;
+        const adb = device.adb;
+        const ADB_WAIT_MS = 15000;
+        const ADB_REVERSE_MS = 20000;
+        const bounded = (timeout) => ({
+            deviceIdentifier: serial,
+            treatErrorsAsWarnings: true,
+            childProcessOptions: { timeout, killSignal: "SIGKILL" },
+        });
+        // `wait-for-device` only blocks until the transport is up; bounded so a
+        // never-ready device can't stall us.
+        await adb.executeCommand(["wait-for-device"], bounded(ADB_WAIT_MS));
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], bounded(ADB_REVERSE_MS));
+            // Verify it landed (a SIGKILL'd-on-timeout reverse resolves rather
+            // than throws, so success of the call isn't proof).
+            const list = (_c = (_b = (_a = (await adb.executeCommand(["reverse", "--list"], bounded(ADB_WAIT_MS)))) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : "";
+            if (list.includes(`tcp:${port}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getViteHmrPort() {
+        // The Vite dev server defaults to 5173; the bundler reads the same
+        // default. If a project runs Vite on a different port, the dev sets
+        // `NS_HMR_PORT` so the CLI reverses the matching port.
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    isTruthyEnvFlag(value) {
+        if (typeof value !== "string") {
+            return false;
+        }
+        const v = value.trim().toLowerCase();
+        return !!v && v !== "0" && v !== "false" && v !== "off" && v !== "no";
+    }
     async syncChangedDataOnDevices(data, projectData, liveSyncInfo) {
         const successfullySyncedMessageFormat = `Successfully synced application %s on device %s.`;
         const rebuiltInformation = {};
@@ -476,18 +618,13 @@ class RunController extends events_1.EventEmitter {
                 }
             }
             catch (err) {
-                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}.`);
+                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}. Will retry on next change.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceError, {
                     projectDir: projectData.projectDir,
                     deviceIdentifier: device.deviceInfo.identifier,
                     applicationIdentifier: projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
                     error: err,
                 });
-                await this.stop({
-                    projectDir: projectData.projectDir,
-                    deviceIdentifiers: [device.deviceInfo.identifier],
-                    stopOptions: { shouldAwaitAllActions: false },
-                });
             }
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => {
@@ -498,15 +635,65 @@ class RunController extends events_1.EventEmitter {
                 _.some(liveSyncProcessInfo.deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier));
         }));
     }
+    scheduleSyncOnDevices(data, projectData, liveSyncInfo) {
+        if (this._syncInProgress) {
+            const platform = data.platform;
+            const existing = this._pendingSyncs.get(platform);
+            if (existing) {
+                existing.data = this.mergeFilesChangeEvents(existing.data, data);
+            }
+            else {
+                this._pendingSyncs.set(platform, { data, projectData, liveSyncInfo });
+            }
+            return;
+        }
+        this.executeSyncOnDevices(data, projectData, liveSyncInfo);
+    }
+    async executeSyncOnDevices(data, projectData, liveSyncInfo) {
+        this._syncInProgress = true;
+        try {
+            await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+        }
+        catch (err) {
+            this.$logger.trace(`Error during sync on devices: ${err.message || err}`);
+        }
+        finally {
+            const nextEntry = this._pendingSyncs.entries().next();
+            if (!nextEntry.done) {
+                const [platform, pending] = nextEntry.value;
+                this._pendingSyncs.delete(platform);
+                this.executeSyncOnDevices(pending.data, pending.projectData, pending.liveSyncInfo);
+            }
+            else {
+                this._syncInProgress = false;
+            }
+        }
+    }
+    mergeFilesChangeEvents(a, b) {
+        return {
+            files: [...new Set([...a.files, ...b.files])],
+            staleFiles: [
+                ...new Set([...(a.staleFiles || []), ...(b.staleFiles || [])]),
+            ],
+            hasOnlyHotUpdateFiles: a.hasOnlyHotUpdateFiles && b.hasOnlyHotUpdateFiles,
+            hasNativeChanges: a.hasNativeChanges || b.hasNativeChanges,
+            hmrData: b.hmrData,
+            platform: b.platform,
+        };
+    }
     async addActionToChain(projectDir, action) {
         const liveSyncInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
         if (liveSyncInfo) {
-            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain.then(async () => {
+            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain
+                .then(async () => {
                 if (!liveSyncInfo.isStopped) {
                     liveSyncInfo.currentSyncAction = action();
                     const res = await liveSyncInfo.currentSyncAction;
                     return res;
                 }
+            })
+                .catch((err) => {
+                this.$logger.warn(`Error in action chain: ${err.message || err}`);
             });
             const result = await liveSyncInfo.actionsChain;
             return result;

package/lib/data/prepare-data.js

@@ -33,6 +33,10 @@ class PrepareData extends controller_data_base_1.ControllerDataBase {
             this.watchNative = data.watchNative;
         }
         this.hostProjectPath = data.hostProjectPath;
+        if (data.skipNative) {
+            this.nativePrepare = { skipNativePrepare: true };
+            this.watchNative = false;
+        }
         this.uniqueBundle = !this.watch && data.uniqueBundle ? Date.now() : 0;
     }
 }