feat(key-shortcuts): r/R/B restart ladder, hint reprint, session scoping

r restarts the app of the running session without preparing, building
or syncing; R prepares again first and rebuilds the native app only if
needed; B always rebuilds it. The help hint is repeated once a burst of
syncs settles, and a restart stays on the devices the session was given
instead of every device attached to the platform.

Author: edusperoni

lib/commands/debug.ts

@@ -180,9 +180,13 @@ export async function runDebugCommand(
 		return;
 	}
 
-	// The device map is what keeps the debugger attached across a restart, so
-	// the shared restart — which knows nothing of it — cannot stand in here.
-	const restartDebugSession = (forceRebuildNativeApp: boolean): Promise<void> =>
+	// The device map is what keeps the debugger attached across a re-prepare,
+	// so the shared restart — which knows nothing of it — cannot stand in here.
+	// The plain app restart needs no stand-in: it goes through the run
+	// controller, whose persisted descriptor already has debugging enabled.
+	const restartDebugSession = (
+		forceRebuildNativeApp: boolean = false,
+	): Promise<void> =>
 		services.$liveSyncCommandHelper.executeLiveSyncOperation(
 			[selectedDeviceForDebug],
 			services.platform,
@@ -193,10 +197,11 @@ export async function runDebugCommand(
 		);
 
 	context.injector.get(KeyShortcutRegistry).add(
-		restartShortcut({ restart: restartDebugSession }),
+		restartShortcut(),
+		restartShortcut({ full: true, restart: () => restartDebugSession() }),
 		restartShortcut({
 			forceRebuildNativeApp: true,
-			restart: restartDebugSession,
+			restart: () => restartDebugSession(true),
 		}),
 		watcherShortcut(),
 	);

lib/commands/run.ts

@@ -159,6 +159,7 @@ export function runCommandShortcuts(
 
 	return [
 		restartShortcut({ platform }),
+		restartShortcut({ platform, full: true }),
 		restartShortcut({ platform, forceRebuildNativeApp: true }),
 		watcherShortcut(),
 	];

lib/controllers/run-controller.ts

@@ -84,6 +84,7 @@ export class RunController extends EventEmitter implements IRunController {
 			projectDir,
 			deviceDescriptors,
 			platforms,
+			liveSyncInfo,
 		);
 
 		const shouldStartWatcher =
@@ -233,6 +234,112 @@ export class RunController extends EventEmitter implements IRunController {
 		);
 	}
 
+	/**
+	 * Restarts the application of a running session without preparing,
+	 * building or syncing anything. Queued on the session's action chain so it
+	 * cannot overtake a sync that is already under way, and routed through
+	 * `refreshApplication` so a debug session gets its debugger back.
+	 */
+	public async restartApplication(
+		data: IRestartApplicationData,
+	): Promise<void> {
+		const { projectDir, deviceIdentifiers } = data;
+		const liveSyncProcessInfo =
+			this.$liveSyncProcessDataService.getPersistedData(projectDir);
+
+		if (!liveSyncProcessInfo || liveSyncProcessInfo.isStopped) {
+			this.$logger.info(
+				"There is no running application to restart. Start a run or debug session first.",
+			);
+			return;
+		}
+
+		const deviceDescriptors = (
+			liveSyncProcessInfo.deviceDescriptors || []
+		).filter(
+			(descriptor) =>
+				!deviceIdentifiers ||
+				!deviceIdentifiers.length ||
+				_.includes(deviceIdentifiers, descriptor.identifier),
+		);
+
+		if (!deviceDescriptors.length) {
+			this.$logger.info("There is no device to restart the application on.");
+			return;
+		}
+
+		const projectData = this.$projectDataService.getProjectData(projectDir);
+		const useHotModuleReload =
+			!!liveSyncProcessInfo.liveSyncInfo?.useHotModuleReload;
+
+		const deviceAction = async (device: Mobile.IDevice) => {
+			const deviceDescriptor = _.find(
+				deviceDescriptors,
+				(dd) => dd.identifier === device.deviceInfo.identifier,
+			);
+
+			try {
+				const platformLiveSyncService =
+					this.$liveSyncServiceResolver.resolveLiveSyncService(
+						device.deviceInfo.platform,
+					);
+				const deviceAppData = await platformLiveSyncService.getAppData({
+					device,
+					watch: true,
+					projectData,
+					liveSyncDeviceData: deviceDescriptor,
+					useHotModuleReload,
+				});
+
+				await this.refreshApplication(
+					projectData,
+					{
+						deviceAppData,
+						modifiedFilesData: [],
+						isFullSync: false,
+						useHotModuleReload,
+					},
+					// Neither a hot update nor a native change, which is what
+					// `refreshApplicationWithoutDebug` reads as "restart".
+					{
+						files: [],
+						staleFiles: [],
+						hasOnlyHotUpdateFiles: false,
+						hasNativeChanges: false,
+						hmrData: null,
+						platform: device.deviceInfo.platform.toLowerCase(),
+					},
+					deviceDescriptor,
+				);
+			} catch (err) {
+				this.$logger.warn(
+					`Unable to restart the application on device: ${device.deviceInfo.identifier}. Error is: ${err.message || err}.`,
+				);
+				this.$logger.trace(err);
+
+				this.emitCore(RunOnDeviceEvents.runOnDeviceError, {
+					projectDir: projectData.projectDir,
+					deviceIdentifier: device.deviceInfo.identifier,
+					applicationIdentifier:
+						projectData.projectIdentifiers[
+							device.deviceInfo.platform.toLowerCase()
+						],
+					error: err,
+				});
+			}
+		};
+
+		await this.addActionToChain(projectDir, () =>
+			this.$devicesService.execute(deviceAction, (device: Mobile.IDevice) =>
+				_.some(
+					deviceDescriptors,
+					(deviceDescriptor) =>
+						deviceDescriptor.identifier === device.deviceInfo.identifier,
+				),
+			),
+		);
+	}
+
 	protected async refreshApplication(
 		projectData: IProjectData,
 		liveSyncResultInfo: ILiveSyncResultInfo,