Merge pull request #938 from doronz88/refactor/remotexpc-to-asyncio

remotexpc: refactor to use asyncio

README.md

@@ -265,9 +265,14 @@ for line in SyslogService(service_provider=rsds[0]).watch():
 # Or you could connect manually to a specific tunnel created by `start-tunnel`
 host = 'fded:c26b:3d2f::1'
 port = 65177
-with RemoteServiceDiscoveryService((host, port)) as rsd:
+async with RemoteServiceDiscoveryService((host, port)) as rsd:
  # you can now use this connection as any other LockdownClient connection
  pass
+
+# Alternatively, you can use this API not in a context-manager
+rsd = RemoteServiceDiscoveryService((host, port))
+await rsd.connect()
+await rsd.close()
 ```
 
 ## Example

pymobiledevice3/bonjour.py

@@ -74,7 +74,8 @@ def query_bonjour(service_names: List[str], ip: str) -> BonjourQuery:
  return BonjourQuery(aiozc, service_browser, listener)
 
 
-async def browse(service_names: List[str], ips: List[str], timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> List[BonjourAnswer]:
+async def browse(service_names: List[str], ips: List[str], timeout: float = DEFAULT_BONJOUR_TIMEOUT) \
+ -> List[BonjourAnswer]:
  bonjour_queries = [query_bonjour(service_names, adapter) for adapter in ips]
  answers = []
  await asyncio.sleep(timeout)

pymobiledevice3/cli/cli_common.py

@@ -21,6 +21,7 @@
 from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
 from pymobiledevice3.tunneld import get_tunneld_devices
 from pymobiledevice3.usbmux import select_devices_by_connection_type
+from pymobiledevice3.utils import get_asyncio_loop
 
 USBMUX_OPTION_HELP = 'usbmuxd listener address (in the form of either /path/to/unix/socket OR HOST:PORT'
 COLORED_OUTPUT = True
@@ -219,7 +220,7 @@ def __init__(self, *args, **kwargs):
  def rsd(self, ctx, param: str, value: Optional[Tuple[str, int]]) -> Optional[RemoteServiceDiscoveryService]:
  if value is not None:
  rsd = RemoteServiceDiscoveryService(value)
- rsd.connect()
+ get_asyncio_loop().run_until_complete(rsd.connect())
  self.service_provider = rsd
  return self.service_provider
 

pymobiledevice3/cli/developer.py

@@ -1,4 +1,5 @@
 # flake8: noqa: C901
+import asyncio
 import json
 import logging
 import os
@@ -10,7 +11,7 @@
 from dataclasses import asdict
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
 import click
 from click.exceptions import MissingParameter, UsageError
@@ -20,8 +21,8 @@
 import pymobiledevice3
 from pymobiledevice3.cli.cli_common import BASED_INT, Command, RSDCommand, default_json_encoder, print_json, \
  user_requested_colored_output
-from pymobiledevice3.exceptions import DeviceAlreadyInUseError, DvtDirListError, ExtractingStackshotError, \
- RSDRequiredError, UnrecognizedSelectorError
+from pymobiledevice3.exceptions import ArgumentError, DeviceAlreadyInUseError, DvtDirListError, \
+ ExtractingStackshotError, RSDRequiredError, UnrecognizedSelectorError
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.osu.os_utils import get_os_utils
@@ -687,20 +688,26 @@ def fetch_symbols():
  pass
 
 
-@fetch_symbols.command('list', cls=Command)
-def fetch_symbols_list(service_provider: LockdownServiceProvider):
- """ list of files to be downloaded """
+async def fetch_symbols_list_task(service_provider: LockdownServiceProvider) -> None:
  if Version(service_provider.product_version) < Version('17.0'):
  print_json(DtFetchSymbols(service_provider).list_files())
  else:
- with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
- print_json([f.file_path for f in fetch_symbols.get_dsc_file_list()])
+ if not isinstance(service_provider, RemoteServiceDiscoveryService):
+ raise ArgumentError('service_provider must be a RemoteServiceDiscoveryService for iOS 17+ devices')
 
+ async with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
+ print_json([f.file_path for f in await fetch_symbols.get_dsc_file_list()])
 
-@fetch_symbols.command('download', cls=Command)
-@click.argument('out', type=click.Path(dir_okay=True, file_okay=False))
-def fetch_symbols_download(service_provider: LockdownServiceProvider, out):
- """ download the linker and dyld cache to a specified directory """
+
+@fetch_symbols.command('list', cls=Command)
+def fetch_symbols_list(service_provider: LockdownServiceProvider) -> None:
+ """ list of files to be downloaded """
+ asyncio.run(fetch_symbols_list_task(service_provider), debug=True)
+
+
+async def fetch_symbols_download_task(service_provider: LockdownServiceProvider, out: str) -> None:
+ if not isinstance(service_provider, RemoteServiceDiscoveryService):
+ raise ArgumentError('service_provider must be a RemoteServiceDiscoveryService for iOS 17+ devices')
 
  out = Path(out)
  out.mkdir(parents=True, exist_ok=True)
@@ -728,8 +735,15 @@ def fetch_symbols_download(service_provider: LockdownServiceProvider, out):
  logger.info(f'writing to: {file}')
  fetch_symbols.get_file(i, f)
  else:
- with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
- fetch_symbols.download(out)
+ async with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
+ await fetch_symbols.download(out)
+
+
+@fetch_symbols.command('download', cls=Command)
+@click.argument('out', type=click.Path(dir_okay=True, file_okay=False))
+def fetch_symbols_download(service_provider: LockdownServiceProvider, out: str) -> None:
+ """ download the linker and dyld cache to a specified directory """
+ asyncio.run(fetch_symbols_download_task(service_provider, out), debug=True)
 
 
 @developer.group('simulate-location')
@@ -1025,66 +1039,101 @@ def dvt_simulate_location_play(service_provider: LockdownClient, filename: str,
 
 
 @developer.group()
-def core_device():
+def core_device() -> None:
  """ core-device options """
  pass
 
 
+async def core_device_list_processes_task(service_provider: RemoteServiceDiscoveryService) -> None:
+ async with AppServiceService(service_provider) as app_service:
+ print_json(await app_service.list_processes())
+
+
 @core_device.command('list-processes', cls=RSDCommand)
-def core_device_list_processes(service_provider: RemoteServiceDiscoveryService):
+def core_device_list_processes(service_provider: RemoteServiceDiscoveryService) -> None:
  """ Get process list """
- with AppServiceService(service_provider) as app_service:
- print_json(app_service.list_processes())
+ asyncio.run(core_device_list_processes_task(service_provider))
+
+
+async def core_device_uninstall_app_task(service_provider: RemoteServiceDiscoveryService,
+ bundle_identifier: str) -> None:
+ async with AppServiceService(service_provider) as app_service:
+ await app_service.uninstall_app(bundle_identifier)
 
 
 @core_device.command('uninstall', cls=RSDCommand)
 @click.argument('bundle_identifier')
-def core_device_uninstall_app(service_provider: RemoteServiceDiscoveryService, bundle_identifier: str):
+def core_device_uninstall_app(service_provider: RemoteServiceDiscoveryService, bundle_identifier: str) -> None:
  """ Uninstall application """
- with AppServiceService(service_provider) as app_service:
- app_service.uninstall_app(bundle_identifier)
+ asyncio.run(core_device_uninstall_app_task(service_provider, bundle_identifier))
+
+
+async def core_device_send_signal_to_process_task(
+ service_provider: RemoteServiceDiscoveryService, pid: int, signal: int) -> None:
+ async with AppServiceService(service_provider) as app_service:
+ print_json(await app_service.send_signal_to_process(pid, signal))
 
 
 @core_device.command('send-signal-to-process', cls=RSDCommand)
 @click.argument('pid', type=click.INT)
 @click.argument('signal', type=click.INT)
-def core_device_send_signal_to_process(service_provider: RemoteServiceDiscoveryService, pid: int, signal: int):
+def core_device_send_signal_to_process(service_provider: RemoteServiceDiscoveryService, pid: int, signal: int) -> None:
  """ Send signal to process """
- with AppServiceService(service_provider) as app_service:
- print_json(app_service.send_signal_to_process(pid, signal))
+ asyncio.run(core_device_send_signal_to_process_task(service_provider, pid, signal))
+
+
+async def core_device_get_device_info_task(service_provider: RemoteServiceDiscoveryService) -> None:
+ async with DeviceInfoService(service_provider) as app_service:
+ print_json(await app_service.get_device_info())
 
 
 @core_device.command('get-device-info', cls=RSDCommand)
-def core_device_get_device_info(service_provider: RemoteServiceDiscoveryService):
+def core_device_get_device_info(service_provider: RemoteServiceDiscoveryService) -> None:
  """ Get device information """
- with DeviceInfoService(service_provider) as app_service:
- print_json(app_service.get_device_info())
+ asyncio.run(core_device_get_device_info_task(service_provider))
+
+
+async def core_device_get_display_info_task(service_provider: RemoteServiceDiscoveryService) -> None:
+ async with DeviceInfoService(service_provider) as app_service:
+ print_json(await app_service.get_display_info())
 
 
 @core_device.command('get-display-info', cls=RSDCommand)
-def core_device_get_display_info(service_provider: RemoteServiceDiscoveryService):
+def core_device_get_display_info(service_provider: RemoteServiceDiscoveryService) -> None:
  """ Get display information """
- with DeviceInfoService(service_provider) as app_service:
- print_json(app_service.get_display_info())
+ asyncio.run(core_device_get_display_info_task(service_provider))
+
+
+async def core_device_query_mobilegestalt_task(service_provider: RemoteServiceDiscoveryService, key: List[str]) -> None:
+ """ Query MobileGestalt """
+ async with DeviceInfoService(service_provider) as app_service:
+ print_json(await app_service.query_mobilegestalt(key))
 
 
 @core_device.command('query-mobilegestalt', cls=RSDCommand)
 @click.argument('key', nargs=-1, type=click.STRING)
-def core_device_query_mobilegestalt(service_provider: RemoteServiceDiscoveryService, key: List[str]):
+def core_device_query_mobilegestalt(service_provider: RemoteServiceDiscoveryService, key: Tuple[str]) -> None:
  """ Query MobileGestalt """
- with DeviceInfoService(service_provider) as app_service:
- print_json(app_service.query_mobilegestalt(list(key)))
+ asyncio.run(core_device_query_mobilegestalt_task(service_provider, list(key)))
+
+
+async def core_device_get_lockstate_task(service_provider: RemoteServiceDiscoveryService) -> None:
+ async with DeviceInfoService(service_provider) as app_service:
+ print_json(await app_service.get_lockstate())
 
 
 @core_device.command('get-lockstate', cls=RSDCommand)
-def core_device_get_lockstate(service_provider: RemoteServiceDiscoveryService):
+def core_device_get_lockstate(service_provider: RemoteServiceDiscoveryService) -> None:
  """ Get lockstate """
- with DeviceInfoService(service_provider) as app_service:
- print_json(app_service.get_lockstate())
+ asyncio.run(core_device_get_lockstate_task(service_provider))
+
+
+async def core_device_list_apps_task(service_provider: RemoteServiceDiscoveryService) -> None:
+ async with AppServiceService(service_provider) as app_service:
+ print_json(await app_service.list_apps())
 
 
 @core_device.command('list-apps', cls=RSDCommand)
-def core_device_list_apps(service_provider: RemoteServiceDiscoveryService):
+def core_device_list_apps(service_provider: RemoteServiceDiscoveryService) -> None:
  """ Get application list """
- with AppServiceService(service_provider) as app_service:
- print_json(app_service.list_apps())
+ asyncio.run(core_device_list_apps_task(service_provider))

pymobiledevice3/remote/core_device/app_service.py

@@ -16,37 +16,37 @@ class AppServiceService(CoreDeviceService):
  def __init__(self, rsd: RemoteServiceDiscoveryService):
  super().__init__(rsd, self.SERVICE_NAME)
 
- def list_apps(self, include_app_clips: bool = True, include_removable_apps: bool = True,
- include_hidden_apps: bool = True, include_internal_apps: bool = True,
- include_default_apps: bool = True) -> List[Mapping]:
+ async def list_apps(self, include_app_clips: bool = True, include_removable_apps: bool = True,
+  include_hidden_apps: bool = True, include_internal_apps: bool = True,
+  include_default_apps: bool = True) -> List[Mapping]:
  """ List applications """
- return self.invoke('com.apple.coredevice.feature.listapps', {
+ return await self.invoke('com.apple.coredevice.feature.listapps', {
  'includeAppClips': include_app_clips, 'includeRemovableApps': include_removable_apps,
  'includeHiddenApps': include_hidden_apps, 'includeInternalApps': include_internal_apps,
  'includeDefaultApps': include_default_apps})
 
- def list_processes(self) -> List[Mapping]:
+ async def list_processes(self) -> List[Mapping]:
  """ List processes """
- return self.invoke('com.apple.coredevice.feature.listprocesses')['processTokens']
+ return (await self.invoke('com.apple.coredevice.feature.listprocesses'))['processTokens']
 
- def list_roots(self) -> Mapping:
+ async def list_roots(self) -> Mapping:
  """
  List roots.
 
  Can only be performed on certain devices
  """
- return self.invoke('com.apple.coredevice.feature.listroots', {
+ return await self.invoke('com.apple.coredevice.feature.listroots', {
  'rootPoint': {
  'relative': '/'
  }})
 
- def spawn_executable(self, executable: str, arguments: List[str]) -> Mapping:
+ async def spawn_executable(self, executable: str, arguments: List[str]) -> Mapping:
  """
  Spawn given executable.
 
  Can only be performed on certain devices
  """
- return self.invoke('com.apple.coredevice.feature.spawnexecutable', {
+ return await self.invoke('com.apple.coredevice.feature.spawnexecutable', {
  'executableItem': {
  'url': {
  '_0': {
@@ -67,36 +67,36 @@ def spawn_executable(self, executable: str, arguments: List[str]) -> Mapping:
  },
  })
 
- def monitor_process_termination(self, pid: int) -> Mapping:
+ async def monitor_process_termination(self, pid: int) -> Mapping:
  """
  Monitor process termination.
 
  Can only be performed on certain devices
  """
- return self.invoke('com.apple.coredevice.feature.monitorprocesstermination', {
+ return await self.invoke('com.apple.coredevice.feature.monitorprocesstermination', {
  'processToken': {'processIdentifier': XpcInt64Type(pid)}})
 
- def uninstall_app(self, bundle_identifier: str) -> None:
+ async def uninstall_app(self, bundle_identifier: str) -> None:
  """
  Uninstall given application by its bundle identifier
  """
- self.invoke('com.apple.coredevice.feature.uninstallapp', {'bundleIdentifier': bundle_identifier})
+ await self.invoke('com.apple.coredevice.feature.uninstallapp', {'bundleIdentifier': bundle_identifier})
 
- def send_signal_to_process(self, pid: int, signal: int) -> Mapping:
+ async def send_signal_to_process(self, pid: int, signal: int) -> Mapping:
  """
  Send signal to given process by its pid
  """
- return self.invoke('com.apple.coredevice.feature.sendsignaltoprocess', {
+ return await self.invoke('com.apple.coredevice.feature.sendsignaltoprocess', {
  'process': {'processIdentifier': XpcInt64Type(pid)},
  'signal': XpcInt64Type(signal),
  })
 
- def fetch_icons(self, bundle_identifier: str, width: float, height: float, scale: float,
- allow_placeholder: bool) -> Mapping:
+ async def fetch_icons(self, bundle_identifier: str, width: float, height: float, scale: float,
+  allow_placeholder: bool) -> Mapping:
  """
  Fetch given application's icons
  """
- return self.invoke('com.apple.coredevice.feature.fetchappicons', {
+ return await self.invoke('com.apple.coredevice.feature.fetchappicons', {
  'width': width,
  'height': height,
  'scale': scale,

pymobiledevice3/remote/core_device/core_device_service.py

@@ -17,10 +17,10 @@ def _generate_core_device_version_dict(version: str) -> Mapping:
 
 
 class CoreDeviceService(RemoteService):
- def invoke(self, feature_identifier: str, input_: Mapping = None) -> Any:
+ async def invoke(self, feature_identifier: str, input_: Mapping = None) -> Any:
  if input_ is None:
  input_ = {}
- response = self.service.send_receive_request({
+ response = await self.service.send_receive_request({
  'CoreDevice.CoreDeviceDDIProtocolVersion': XpcInt64Type(0),
  'CoreDevice.action': {},
  'CoreDevice.coreDeviceVersion': CORE_DEVICE_VERSION,

pymobiledevice3/remote/core_device/device_info.py

@@ -14,28 +14,28 @@ class DeviceInfoService(CoreDeviceService):
  def __init__(self, rsd: RemoteServiceDiscoveryService):
  super().__init__(rsd, self.SERVICE_NAME)
 
- def get_device_info(self) -> Mapping:
+ async def get_device_info(self) -> Mapping:
  """
  Get device information
  """
- return self.invoke('com.apple.coredevice.feature.getdeviceinfo', {})
+ return await self.invoke('com.apple.coredevice.feature.getdeviceinfo', {})
 
- def get_display_info(self) -> Mapping:
+ async def get_display_info(self) -> Mapping:
  """
  Get display information
  """
- return self.invoke('com.apple.coredevice.feature.getdisplayinfo', {})
+ return await self.invoke('com.apple.coredevice.feature.getdisplayinfo', {})
 
- def query_mobilegestalt(self, keys: List[str]) -> Mapping:
+ async def query_mobilegestalt(self, keys: List[str]) -> Mapping:
  """
  Query MobileGestalt.
 
  Can only be performed to specific devices
  """
- return self.invoke('com.apple.coredevice.feature.querymobilegestalt', {'keys': keys})
+ return await self.invoke('com.apple.coredevice.feature.querymobilegestalt', {'keys': keys})
 
- def get_lockstate(self) -> Mapping:
+ async def get_lockstate(self) -> Mapping:
  """
  Get lockstate
  """
- return self.invoke('com.apple.coredevice.feature.getlockstate', {})
+ return await self.invoke('com.apple.coredevice.feature.getlockstate', {})