appium-ios-remotexpc 0.8.0 → 0.10.0

package/src/services/ios/power-assertion/index.ts

@@ -0,0 +1,100 @@
+import { logger } from '@appium/support';
+
+import type {
+  PlistDictionary,
+  PowerAssertionService as PowerAssertionServiceInterface,
+} from '../../../lib/types.js';
+import { ServiceConnection } from '../../../service-connection.js';
+import { BaseService } from '../base-service.js';
+
+const log = logger.getLogger('PowerAssertionService');
+
+/**
+ * Power assertion types that can be used to prevent system sleep
+ */
+export enum PowerAssertionType {
+  WIRELESS_SYNC = 'AMDPowerAssertionTypeWirelessSync',
+  PREVENT_USER_IDLE_SYSTEM_SLEEP = 'PreventUserIdleSystemSleep',
+  PREVENT_SYSTEM_SLEEP = 'PreventSystemSleep',
+}
+
+/**
+ * Options for power assertion creation
+ */
+export interface PowerAssertionOptions {
+  type: PowerAssertionType;
+  name: string;
+  timeout: number; // timeout in seconds
+  details?: string;
+}
+
+/**
+ * PowerAssertionService provides an API to create power assertions.
+ */
+class PowerAssertionService
+  extends BaseService
+  implements PowerAssertionServiceInterface
+{
+  static readonly RSD_SERVICE_NAME =
+    'com.apple.mobile.assertion_agent.shim.remote';
+
+  private _conn: ServiceConnection | null = null;
+
+  /**
+   * Create a power assertion to prevent system sleep
+   * @param options Options for creating the power assertion
+   * @returns Promise that resolves when the assertion is created
+   */
+  async createPowerAssertion(options: PowerAssertionOptions): Promise<void> {
+    if (!this._conn) {
+      this._conn = await this.connectToPowerAssertionService();
+    }
+
+    const request = this.buildCreateAssertionRequest(options);
+    await this._conn.sendPlistRequest(request);
+    log.info(
+      `Power assertion created: type="${options.type}", name="${options.name}", timeout=${options.timeout}s`,
+    );
+  }
+
+  /**
+   * Close the connection to the power assertion service
+   */
+  async close(): Promise<void> {
+    if (this._conn) {
+      await this._conn.close();
+      this._conn = null;
+      log.debug('Power assertion service connection closed');
+    }
+  }
+
+  private async connectToPowerAssertionService(): Promise<ServiceConnection> {
+    const service = {
+      serviceName: PowerAssertionService.RSD_SERVICE_NAME,
+      port: this.address[1].toString(),
+    };
+    log.debug(
+      `Connecting to power assertion service at ${this.address[0]}:${this.address[1]}`,
+    );
+    return await this.startLockdownService(service);
+  }
+
+  private buildCreateAssertionRequest(
+    options: PowerAssertionOptions,
+  ): PlistDictionary {
+    const request: PlistDictionary = {
+      CommandKey: 'CommandCreateAssertion',
+      AssertionTypeKey: options.type,
+      AssertionNameKey: options.name,
+      AssertionTimeoutKey: options.timeout,
+    };
+
+    if (options.details !== undefined) {
+      request.AssertionDetailKey = options.details;
+    }
+
+    return request;
+  }
+}
+
+export { PowerAssertionService };

package/src/services.ts

@@ -8,14 +8,17 @@ import type {
   MobileConfigServiceWithConnection,
   MobileImageMounterServiceWithConnection,
   NotificationProxyServiceWithConnection,
+  PowerAssertionServiceWithConnection,
   SpringboardServiceWithConnection,
   SyslogService as SyslogServiceType,
   WebInspectorServiceWithConnection,
 } from './lib/types.js';
+import AfcService from './services/ios/afc/index.js';
 import DiagnosticsService from './services/ios/diagnostic-service/index.js';
 import { MobileConfigService } from './services/ios/mobile-config/index.js';
 import MobileImageMounterService from './services/ios/mobile-image-mounter/index.js';
 import { NotificationProxyService } from './services/ios/notification-proxy/index.js';
+import { PowerAssertionService } from './services/ios/power-assertion/index.js';
 import { SpringBoardService } from './services/ios/springboard-service/index.js';
 import SyslogService from './services/ios/syslog-service/index.js';
 import { WebInspectorService } from './services/ios/webinspector/index.js';
@@ -70,6 +73,7 @@ export async function startMobileConfigService(
     ]),
   };
 }
+
 export async function startMobileImageMounterService(
   udid: string,
 ): Promise<MobileImageMounterServiceWithConnection> {
@@ -102,6 +106,22 @@ export async function startSpringboardService(
   };
 }
 
+export async function startPowerAssertionService(
+  udid: string,
+): Promise<PowerAssertionServiceWithConnection> {
+  const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
+  const powerAssertionService = remoteXPC.findService(
+    PowerAssertionService.RSD_SERVICE_NAME,
+  );
+  return {
+    remoteXPC: remoteXPC as RemoteXpcConnection,
+    powerAssertionService: new PowerAssertionService([
+      tunnelConnection.host,
+      parseInt(powerAssertionService.port, 10),
+    ]),
+  };
+}
+
 export async function startSyslogService(
   udid: string,
 ): Promise<SyslogServiceType> {
@@ -109,6 +129,19 @@ export async function startSyslogService(
   return new SyslogService([tunnelConnection.host, tunnelConnection.port]);
 }
 
+/**
+ * Start AFC service over RemoteXPC shim.
+ * Resolves the AFC service port via RemoteXPC and returns a ready-to-use AfcService instance.
+ */
+export async function startAfcService(udid: string): Promise<AfcService> {
+  const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
+  const afcDescriptor = remoteXPC.findService(AfcService.RSD_SERVICE_NAME);
+  return new AfcService([
+    tunnelConnection.host,
+    parseInt(afcDescriptor.port, 10),
+  ]);
+}
+
 export async function startWebInspectorService(
   udid: string,
 ): Promise<WebInspectorServiceWithConnection> {