feat(iOS): Add 5 second retry on DeviceLocked for iOS (#167)

Co-authored-by: Joseph Pender <joey@prodcode.net> Co-authored-by: Dan Imhoff <dwieeb@gmail.com>
ionic-team · Dec 7, 2020 · f451e46 · f451e46
1 parent b0b8978
commit f451e46
Show file tree

Hide file tree

Showing 7 changed files with 129 additions and 33 deletions.
diff --git a/src/errors.ts b/src/errors.ts
@@ -67,6 +67,7 @@ export const ERR_SDK_UNSATISFIED_PACKAGES = 'ERR_SDK_UNSATISFIED_PACKAGES';
 export const ERR_TARGET_NOT_FOUND = 'ERR_TARGET_NOT_FOUND';
 export const ERR_NO_DEVICE = 'ERR_NO_DEVICE';
 export const ERR_NO_TARGET = 'ERR_NO_TARGET';
+export const ERR_DEVICE_LOCKED = 'ERR_DEVICE_LOCKED';
 export const ERR_UNKNOWN_AVD = 'ERR_UNKNOWN_AVD';
 export const ERR_UNSUPPORTED_API_LEVEL = 'ERR_UNSUPPORTED_API_LEVEL';
 
@@ -123,7 +124,8 @@ export class SDKException extends AndroidException<SDKExceptionCode> {}
 export type IOSRunExceptionCode =
   | typeof ERR_TARGET_NOT_FOUND
   | typeof ERR_NO_DEVICE
-  | typeof ERR_NO_TARGET;
+  | typeof ERR_NO_TARGET
+  | typeof ERR_DEVICE_LOCKED;
 
 export class IOSRunException extends Exception<IOSRunExceptionCode> {}
 

diff --git a/src/ios/lib/lib-errors.ts b/src/ios/lib/lib-errors.ts
@@ -0,0 +1,10 @@
+/**
+ * Type union of error codes we get back from the protocol.
+ */
+export type IOSLibErrorCode = 'DeviceLocked';
+
+export class IOSLibError extends Error implements NodeJS.ErrnoException {
+  constructor(message: string, readonly code: IOSLibErrorCode) {
+    super(message);
+  }
+}
diff --git a/src/ios/lib/protocol/lockdown.ts b/src/ios/lib/protocol/lockdown.ts
@@ -2,6 +2,8 @@ import * as Debug from 'debug';
 import type * as net from 'net';
 import * as plist from 'plist';
 
+import { IOSLibError } from '../lib-errors';
+
 import type { ProtocolWriter } from './protocol';
 import {
   PlistProtocolReader,
@@ -70,6 +72,10 @@ export class LockdownProtocolReader extends PlistProtocolReader {
     const resp = super.parseBody(data);
     debug(`Response: ${JSON.stringify(resp)}`);
     if (isLockdownErrorResponse(resp)) {
+      if (resp.Error === 'DeviceLocked') {
+        throw new IOSLibError('Device is currently locked.', 'DeviceLocked');
+      }
+
       throw new Error(resp.Error);
     }
     return resp;

diff --git a/src/ios/run.ts b/src/ios/run.ts
@@ -6,17 +6,109 @@ import * as path from 'path';
 import {
   CLIException,
   ERR_BAD_INPUT,
+  ERR_DEVICE_LOCKED,
   ERR_TARGET_NOT_FOUND,
   IOSRunException,
 } from '../errors';
 import { getOptionValue } from '../utils/cli';
+import { wait } from '../utils/process';
 
+import type { DeviceValues } from './lib';
+import { IOSLibError } from './lib/lib-errors';
 import { getBundleId, unzipIPA } from './utils/app';
 import { getConnectedDevices, runOnDevice } from './utils/device';
+import type { SimulatorResult } from './utils/simulator';
 import { getSimulators, runOnSimulator } from './utils/simulator';
 
 const debug = Debug('native-run:ios:run');
 
+interface IOSRunConfig {
+  udid?: string;
+  devices: DeviceValues[];
+  simulators: SimulatorResult[];
+  appPath: string;
+  bundleId: string;
+  waitForApp: boolean;
+  preferSimulator: boolean;
+}
+
+async function runIpaOrAppFile({
+  udid,
+  devices,
+  simulators,
+  appPath,
+  bundleId,
+  waitForApp,
+  preferSimulator,
+}: IOSRunConfig): Promise<void> {
+  if (udid) {
+    if (devices.find(d => d.UniqueDeviceID === udid)) {
+      await runOnDevice(udid, appPath, bundleId, waitForApp);
+    } else if (simulators.find(s => s.udid === udid)) {
+      await runOnSimulator(udid, appPath, bundleId, waitForApp);
+    } else {
+      throw new IOSRunException(
+        `No device or simulator with UDID "${udid}" found`,
+        ERR_TARGET_NOT_FOUND,
+      );
+    }
+  } else if (devices.length && !preferSimulator) {
+    // no udid, use first connected device
+    await runOnDevice(devices[0].UniqueDeviceID, appPath, bundleId, waitForApp);
+  } else {
+    // use default sim
+    await runOnSimulator(
+      simulators[simulators.length - 1].udid,
+      appPath,
+      bundleId,
+      waitForApp,
+    );
+  }
+}
+
+async function runIpaOrAppFileOnInterval(config: IOSRunConfig): Promise<void> {
+  const maxRetryCount = 12; // 1 minute
+  const retryInterval = 5000; // 5 seconds
+  let error: Error | undefined;
+  let retryCount = 0;
+
+  const retry = async () => {
+    process.stderr.write('Please unlock your device. Waiting 5 seconds...\n');
+    retryCount++;
+    await wait(retryInterval);
+    await run();
+  };
+
+  const run = async () => {
+    try {
+      await runIpaOrAppFile(config);
+    } catch (err) {
+      if (
+        err instanceof IOSLibError &&
+        err.code == 'DeviceLocked' &&
+        retryCount < maxRetryCount
+      ) {
+        await retry();
+      } else {
+        if (maxRetryCount >= retryCount) {
+          error = new IOSRunException(
+            `Device still locked after 1 minute. Aborting.`,
+            ERR_DEVICE_LOCKED,
+          );
+        } else {
+          error = err;
+        }
+      }
+    }
+  };
+
+  await run();
+
+  if (error) {
+    throw error;
+  }
+}
+
 export async function run(args: readonly string[]): Promise<void> {
   let appPath = getOptionValue(args, '--app');
   if (!appPath) {
@@ -47,34 +139,17 @@ export async function run(args: readonly string[]): Promise<void> {
       getSimulators(),
     ]);
     // try to run on device or simulator with udid
-    if (udid) {
-      if (devices.find(d => d.UniqueDeviceID === udid)) {
-        await runOnDevice(udid, appPath, bundleId, waitForApp);
-      } else if (simulators.find(s => s.udid === udid)) {
-        await runOnSimulator(udid, appPath, bundleId, waitForApp);
-      } else {
-        throw new IOSRunException(
-          `No device or simulator with UDID "${udid}" found`,
-          ERR_TARGET_NOT_FOUND,
-        );
-      }
-    } else if (devices.length && !preferSimulator) {
-      // no udid, use first connected device
-      await runOnDevice(
-        devices[0].UniqueDeviceID,
-        appPath,
-        bundleId,
-        waitForApp,
-      );
-    } else {
-      // use default sim
-      await runOnSimulator(
-        simulators[simulators.length - 1].udid,
-        appPath,
-        bundleId,
-        waitForApp,
-      );
-    }
+    const config: IOSRunConfig = {
+      udid,
+      devices,
+      simulators,
+      appPath,
+      bundleId,
+      waitForApp,
+      preferSimulator,
+    };
+
+    await runIpaOrAppFileOnInterval(config);
   } finally {
     if (isIPA) {
       try {

diff --git a/src/ios/utils/device.ts b/src/ios/utils/device.ts
@@ -1,10 +1,9 @@
 import * as Debug from 'debug';
 import { readFileSync } from 'fs';
 import * as path from 'path';
-import { promisify } from 'util';
 
 import { Exception } from '../../errors';
-import { onBeforeExit } from '../../utils/process';
+import { onBeforeExit, wait } from '../../utils/process';
 import type { DeviceValues, IPLookupResult } from '../lib';
 import {
   AFCError,
@@ -17,7 +16,6 @@ import {
 import { getDeveloperDiskImagePath } from './xcode';
 
 const debug = Debug('native-run:ios:utils:device');
-const wait = promisify(setTimeout);
 
 export async function getConnectedDevices() {
   const usbmuxClient = new UsbmuxdClient(UsbmuxdClient.connectUsbmuxdSocket());

diff --git a/src/ios/utils/simulator.ts b/src/ios/utils/simulator.ts
@@ -39,7 +39,11 @@ interface SimCtlOutput {
   readonly devicetypes: SimCtlType[];
 }
 
-export async function getSimulators() {
+export interface SimulatorResult extends Simulator {
+  runtime: SimCtlRuntime;
+}
+
+export async function getSimulators(): Promise<SimulatorResult[]> {
   const simctl = spawnSync('xcrun', ['simctl', 'list', '--json'], {
     encoding: 'utf8',
   });

diff --git a/src/utils/process.ts b/src/utils/process.ts
@@ -8,6 +8,7 @@ const debug = Debug('native-run:utils:process');
 
 export const exec = util.promisify(cp.exec);
 export const execFile = util.promisify(cp.execFile);
+export const wait = util.promisify(setTimeout);
 
 export type ExitQueueFn = () => Promise<void>;