# `DalaDev.Discovery.IOS`
[🔗](https://github.com/manhvu/dala_dev/blob/main/lib/dala_dev/discovery/ios.ex#L1)

Discovers iOS simulators via xcrun simctl.

Physical iOS device support requires libimobiledevice (ideviceinfo, iproxy).
Best-effort: works if tools are installed, degrades gracefully if not.

# `devicectl_ipv4_addresses`

```elixir
@spec devicectl_ipv4_addresses() :: [String.t()]
```

Returns the IPv4 addresses every connected physical device is known to
reach Mac at, derived from `xcrun devicectl list devices --json-output`.
Sources, in order:

  1. `connectionProperties.tunnelIPAddress` if it's an IPv4 (CoreDevice
     USB tunnel; sometimes IPv6, which Erlang dist doesn't speak)
  2. `connectionProperties.localHostnames` resolved via `:inet.gethostbyname/1`
     (mDNS hostnames like `Kevins-iPhone.coredevice.local`, which usually
     resolve to the device's WiFi IPv4)

Returns `[]` if `xcrun` isn't installed, the JSON parse fails, or no
device has any IPv4. Pure of side effects beyond the temp file used to
capture devicectl's JSON output.

# `enable_accessibility`

```elixir
@spec enable_accessibility(String.t()) :: :ok
```

Enables the iOS accessibility system for the given simulator (or "booted").

SwiftUI lazily populates its accessibility tree only when an accessibility
service is active. `pegleg_nif:ui_tree/0` requires this to be called once
per simulator session before it can return elements. Writes the VoiceOver
preference into the simulator's preference store and posts the Darwin
notification that UIKit listens to.

Safe to call repeatedly — idempotent.

# `find_physical_at`

```elixir
@spec find_physical_at(String.t()) :: DalaDev.Device.t() | nil
```

Queries EPMD at a specific IP for any `*_ios` node and returns a Device, or
nil if no iOS BEAM node is reachable there. Used for direct connection when
the IP is already known (e.g. from xcrun devicectl) and ARP may not be warm.

# `launch_app`

```elixir
@spec launch_app(String.t(), String.t(), keyword()) :: {String.t(), non_neg_integer()}
```

Launches the app on a booted simulator.

Passes two env vars through to the simulator app via `simctl`'s
`SIMCTL_CHILD_*` mechanism (the prefix is stripped before delivery):

  * `DALA_DIST_PORT`        — Erlang dist listen port
  * `DALA_SIM_RUNTIME_DIR`  — directory the OTP runtime was written to,
    so `dala_beam.m` reads from the same place `ios/build.sh` wrote.
    Resolved by `DalaDev.Paths.sim_runtime_dir/1`.

# `list_devices`

```elixir
@spec list_devices() :: [DalaDev.Device.t()]
```

Returns all iOS devices (simulators + physical).

# `list_physical`

```elixir
@spec list_physical() :: [DalaDev.Device.t()]
```

Returns connected physical iOS devices.

Always runs both USB discovery (`ideviceinfo`) and a LAN EPMD scan in
parallel. The LAN scan finds the device's actual node IP (which is
WiFi-first since dala_beam.m prefers a stable LAN address). The USB scan
provides the UDID and device name. Results are merged: one device with the
correct WiFi IP and full USB metadata.

If only one path finds the device, that result is used directly — so this
works on USB-only setups and WiFi-only setups equally. When USB finds a
device but LAN scan doesn't (cold ARP, rapid app launch, etc.), the
result is enriched via `xcrun devicectl` — we ask for the device's known
hostnames + tunnel IPs, resolve to IPv4, and probe each with EPMD. Single
TCP probe per candidate, so it costs ~50 ms in the success case and
doesn't slow down the no-iOS path.

# `list_simulators`

```elixir
@spec list_simulators() :: [DalaDev.Device.t()]
```

Returns booted iOS simulators.

# `parse_runtime_version`

```elixir
@spec parse_runtime_version(String.t()) :: String.t()
```

Parses a CoreSimulator runtime key into a human-readable version string. Exposed for testing.

# `parse_simctl_json`

```elixir
@spec parse_simctl_json(String.t()) :: [DalaDev.Device.t()]
```

Parses the JSON output of `xcrun simctl list devices booted --json`.
Exposed for testing.

# `parse_simctl_text`

```elixir
@spec parse_simctl_text(String.t()) :: [DalaDev.Device.t()]
```

Parses the plain-text output of `xcrun simctl list devices booted`.
Exposed for testing.

# `restart_app_physical`

```elixir
@spec restart_app_physical(String.t(), String.t()) :: {String.t(), non_neg_integer()}
```

Restarts the app on a physical iOS device via xcrun devicectl.
Kills any other user-installed app first (they all share EPMD port 4369 and
only one can run at a time), then launches the target app fresh.

# `terminate_app`

```elixir
@spec terminate_app(String.t(), String.t()) :: {String.t(), non_neg_integer()}
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*