@desklink/react-native 0.2.0 → 0.3.1

package/README.md

@@ -1,6 +1,16 @@
-# @desklink/react-native
+<h1 align="center">@desklink/react-native</h1>
 
-Show a live desktop in a React Native app, and drive it from the phone.
+<p align="center">
+  <a href="https://www.npmjs.com/package/@desklink/react-native"><img alt="npm" src="https://img.shields.io/npm/v/@desklink/react-native?style=flat&label=npm" /></a>
+  <a href="https://github.com/umeranjum17/desklink/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/umeranjum17/desklink/ci.yml?style=flat&branch=main" /></a>
+  <a href="LICENSE"><img alt="Apache 2.0" src="https://img.shields.io/badge/license-Apache--2.0-666?style=flat" /></a>
+  <img alt="Android, iOS and web" src="https://img.shields.io/badge/Android%20%7C%20iOS%20%7C%20web-111?style=flat" />
+</p>
+
+<p align="center">
+  <strong>Show a live desktop in a React Native app, and drive it from the phone.</strong><br/>
+  It renders a desktop that <code>@desklink/host</code> serves on Android, iOS and the web, with touch as a desktop pointer the phone can see, sticky modifier keys, and a session that recovers from a dropped network on its own.
+</p>
 
 The package is a **view and a session**, not a screen: it renders the picture and
 turns touch, the keyboard and the clipboard into that session's input. Where it
@@ -9,6 +19,10 @@ the application.
 
 ## Install
 
+The npm badge at the top of this page tracks the registry version, and npm
+verifies package integrity on install. See the [changelog](../../CHANGELOG.md)
+for release changes. Supported platforms: Android, iOS and web.
+
 The package contains native code and is not an Expo Go package. Inside this
 repository it resolves through the workspace; anywhere else, install it from npm:
 
@@ -17,10 +31,29 @@ npx expo install @desklink/react-native      # or yarn add, then prebuild/rebuil
 ```
 
 Android uses an Expo native module; iOS uses the app's existing
-`react-native-webrtc` peer connection and `RTCView` from JavaScript. Both need a
-dev client or native build containing that binding. Web uses the browser's WebRTC.
+`react-native-webrtc` peer connection and `RTCView` from JavaScript, plus a small
+Expo module of its own for the hardware keyboard and an iPad pointer. Both need a
+dev client or native build containing that binding ([development builds](https://docs.expo.dev/develop/development-builds/introduction/); [Expo Go](https://docs.expo.dev/workflow/expo-go/) cannot load them). Web uses the browser's WebRTC.
 No second WebRTC binary is linked. The Android module has its own hardware-first
-decoder factory; iOS uses the decoder shipped by `react-native-webrtc`.
+decoder factory; iOS uses the decoder shipped by `react-native-webrtc` and asks
+the host for H.264, which that decoder runs in hardware.
+
+On iOS the WebRTC binding also needs its config plugin
+(`@config-plugins/react-native-webrtc` — 14.x for Expo SDK 55, 15.x for
+Expo SDK 56 and later):
+
+```json
+{ "expo": { "plugins": ["@config-plugins/react-native-webrtc", "@desklink/react-native"] } }
+```
+
+On iPad, a trackpad or mouse hovers and scrolls the desktop as it is. For its
+presses to carry their buttons — a click-drag that selects, a secondary click
+that is a right click — the package's entry in the plugins list above sets
+[`UIApplicationSupportsIndirectInputEvents`](https://developer.apple.com/documentation/bundleresources/information-property-list/uiapplicationsupportsindirectinputevents).
+
+That key changes how every screen of the app receives trackpad input, so the
+package never sets it on its own; without the plugin nothing about the app
+changes, and trackpad presses reach the desktop as touches.
 
 ## Use
 
@@ -56,22 +89,53 @@ import { desktopAvailable } from '@desklink/react-native/availability';
 {desktopAvailable && <ComputerAction onPress={openDesktop} />}
 ```
 
+### Frame rate and encode size
+
+The engine streams at up to 60 fps unless `session.maxFps` names a lower cap —
+omit it for the smooth path. A still desktop costs nothing at 60, because the
+engine only produces frames on change.
+
+Keep the encoded picture inside a 1920×1080 box:
+
+```tsx
+session: { permissions: CONTROL_PERMISSIONS, maxWidth: 1920, maxHeight: 1080 },
+```
+
+The engine never upscales, so a smaller desktop is sent at its own size and a
+larger one is scaled to fit. Above that box the encoder cannot sustain 50+ fps
+under full-screen motion.
+
+On iOS, keep the box at or below the device's own pixels and `maxFps` at 30:
+the iOS receiver asks the engine for H.264, which iOS decodes in hardware
+(VideoToolbox), but a host without an H.264 encoder still sends VP9, which
+iOS decodes in software — so a 1440p or 4K picture on such a host costs CPU,
+heat and battery.
+
 ### What the package guarantees
 
-- **VP9 decoding.** Android builds a session-scoped hardware-first decoder
+- **Hardware decoding where the platform has it.** Android and web decode the
+  host's default VP9; Android builds a session-scoped hardware-first decoder
   factory with software fallback. iOS uses the app's `react-native-webrtc`
-  decoder; neither platform links a second WebRTC stack.
+  decoder, which decodes H.264 through VideoToolbox but VP9 only in software,
+  so the iOS receiver asks for H.264 by putting it first in the offer it
+  applies; a host with an H.264 encoder then sends H.264, and one without sends
+  VP9. Neither platform links a second WebRTC stack.
 - **A sharp, zoomable picture.** The desktop fits the view by default; a pinch
   zooms up to 2.5 view pixels per desktop pixel and one finger moves around the
   zoomed desktop. On Android the decoded frame is copied once into the view's
   own texture and drawn with a multi-tap filter when it is shown smaller than
   its size, so a fitted 4K desktop does not alias and a pinch redraws at once.
-  iOS uses `RTCView`'s native renderer. `fitToView()` shows the whole desktop again.
+  iOS uses `RTCView`'s native renderer. That renderer draws a frame only when
+  its timestamp is new, and a receiver honouring the engine's zero playout delay
+  stamps every frame alike, so the iOS peer declines that hint and keeps the
+  receiver's usual jitter buffer. `fitToView()` shows the whole desktop again.
 - **A pointer a phone can see.** Once a touch has sent the desktop's pointer
-  somewhere, the view draws it there at a readable size, over a picture whose
-  own cursor is a few pixels tall or not captured at all. Android hides the
-  extra mark when a mouse is attached, and the `device` profile draws no mark
-  on any platform — the screen being touched shows the finger itself.
+  somewhere, the view draws an outlined arrow there at a readable size, over a
+  picture whose own cursor is a few pixels tall or not captured at all. On iOS,
+  the arrow tip marks the desktop pointer position. Android hides the extra
+  mark when a mouse is attached, iOS when an iPad trackpad or mouse drives it,
+  and the `device` profile draws no mark on any platform — the screen being
+  touched shows the finger itself.
 - **The picture above the keyboard.** While the phone's keyboard is up, the
   picture sits above it and above the room the app keeps for its own controls
   (`keyboardClearance`). Android follows the keyboard animation and keeps the
@@ -97,19 +161,31 @@ import { desktopAvailable } from '@desklink/react-native/availability';
   release, so a tap clicks and a hold holds with no long-press right click,
   and no drawn pointer — while the default `desktop` is the trackpad above.
   Two fingers scroll and pinch the same under every profile.
+- **A hardware keyboard and a trackpad.** A hardware keyboard's keys reach the
+  desktop with their down and up and what is held: arrows, Esc, Tab, Home/End,
+  Page Up/Down, Delete and the modifiers, with Control and Command
+  chords as the key's own letter (iOS sends Command as the desktop's Meta);
+  other keys type their text. On iOS the view holds the keyboard while control
+  is enabled and gives it to the on-screen keyboard while the app shows it;
+  shortcuts the system keeps, such as Command-Tab and the Globe key, stay with
+  the system. An iPad pointer hovers the desktop's pointer, scrolls under it,
+  and — with the config plugin — presses, drags and right-clicks with its own
+  buttons.
 - **The keys a phone lacks.** `modifiers`, `tapModifier` and `pressKey` give
   sticky Ctrl and Shift: tap arms one for the next key, tap again locks it.
   While one is armed, the next key or character the phone's keyboard types is
   sent as that key's chord, so Ctrl then v is Ctrl+V. The app draws the keys.
-- **Readiness is a rendered frame.** Android marks the first draw; iOS uses
-  `RTCView`'s native video-dimensions callback, which fires after a decoded
-  picture arrives. Neither marks a track or ICE connection as live.
+- **Readiness is a rendered frame.** Android marks the first draw; iOS marks
+  the first `RTCView` video-dimensions callback and ignores later ones, so a
+  resize or remount during a reconnect does not read as live. Neither marks
+  a track or ICE connection as live.
 - **Connection states, as they happen.** The session status is `idle`,
   `opening`, `connecting`, `live`, `reconnecting`, `ended` or `failed`. The
   peer's ICE state and the engine's `session.state` both feed it: a
   `disconnected` path reads as `reconnecting` within about a second of the
   drop — never a frozen picture that still says live — and a recovered path
-  reads as `live` again once ICE is `connected`. `failed` stays terminal.
+  reads as `live` again once ICE is `connected`. A path that reports
+  `failed` reopens the session with fresh authority instead of staying stuck.
   Every event carries its engine session id where the carrier preserves it,
   and the session ignores anything naming a session it no longer holds, so a
   previous generation's queued offer or revocation cannot corrupt or kill a
@@ -126,7 +202,12 @@ import { desktopAvailable } from '@desklink/react-native/availability';
   `session.description` event and is answered as usual, all without reopening
   the session. The first restart waits ~2 s for blips that heal alone;
   retries back off across ~60 s, so a 30–60 s outage still recovers when the
-  network returns. Only a terminal `failed` reopens the session, and those
+  network returns. When the restart schedule is spent without the peer
+  reporting `failed`, the session reopens instead of sitting in
+  `reconnecting`. An engine revocation with code `transport` (the path was
+  lost) also reopens the session; any other revocation code, or none, ends
+  it, as does a deliberate close. A return to the foreground after ~30 s away
+  reopens at once rather than spending restarts on a lapsed path. Those
   reopens back off across ~60 s too instead of spending one attempt while the
   network is still down. Renegotiation transients from a restart the session
   asked for itself are expected, not a new outage: they neither flip the
@@ -144,7 +225,10 @@ import { desktopAvailable } from '@desklink/react-native/availability';
 ### `Signaling`
 
 The one thing the app must supply. It carries the engine's local protocol over
-whatever authenticated channel the app already has:
+whatever authenticated channel the app already has.
+
+See the [BYOKit integration guidance](../../README.md#why-desklink-exists)
+for the application's pairing, identity and signaling transport.
 
 ```ts
 interface Signaling {
@@ -158,6 +242,78 @@ interface Signaling {
 candidates, state and revocation. Pixels and input do **not** use this
 channel — they are the desktop's own WebRTC session.
 
+## Shipping on iOS
+
+What the consuming app — not this package — must get right before review.
+
+- **Local network.** A direct LAN session connects to host ICE candidates,
+  which prompts for local-network access, so the app needs
+  `NSLocalNetworkUsageDescription`. The first connection can be denied before
+  the user answers; the session's restart/reopen path recovers from that.
+  `NSBonjourServices` is only needed if the app adds its own Bonjour
+  discovery — desklink discovers no hosts. Relay-only sessions never prompt.
+  For app-supplied routes, see the
+  [BYOKit integration guidance](../../README.md#why-desklink-exists).
+  See [TN3179](https://developer.apple.com/documentation/technotes/tn3179-understanding-local-network-privacy).
+- **Export compliance.** The viewer's DTLS-SRTP comes from libwebrtc bundled
+  with `react-native-webrtc`, not from the OS, so the app must check the
+  exemption criteria itself rather than assume
+  `ITSAppUsesNonExemptEncryption` is `NO` — standard-protocol encryption is
+  commonly exempt but can still need a yearly self-classification report.
+  See [complying with encryption export regulations](https://developer.apple.com/documentation/security/complying-with-encryption-export-regulations).
+- **Review.** A viewer that mirrors the whole host device generically falls
+  outside the remote-desktop conditions; one that mirrors only specific
+  software must connect LAN-only to a user-owned host. Which case applies is
+  the app's product shape to decide. Declare no `audio` or `voip` background
+  mode to keep the stream alive — review rejects that. See the
+  [App Store review guidelines](https://developer.apple.com/app-store/review/guidelines/)
+  (§4.2.7, §2.5.4).
+- **Backgrounding.** There is no compliant background mode for a desktop
+  stream: an app away longer than ~30 s comes back to a closed session, and
+  the session reopens on return to the foreground rather than resuming. Keep
+  disabling input on background; the engine releases held keys within
+  seconds of the path dying, so nothing stays stuck.
+
+## iOS simulator proof
+
+`example/` is the smallest app that shows a desktop: a native (non-Expo Go)
+build with `react-native-webrtc`, connecting to `desklink-host bridge` with the
+URL it is launched with. `test/ios-flow.mjs` builds it for the iOS simulator on
+a Mac over ssh, serves a private Xvfb desktop from this machine through the
+bridge, and checks that the first frame is presented, that the answer puts
+H.264 first with NACK when the host offers it (VP9 otherwise; both descriptions
+are written out), that a tap clicks the host, that
+the picture keeps following the desktop afterwards, and that hardware keys
+pressed on the simulator reach the desktop. With `DESKLINK_IOS_IPAD=1` it runs on
+an iPad simulator and also drives a trackpad through XCUITest
+(`test/ios-pointer/`): hover, a click-drag that selects text, a right click and
+a scroll:
+
+```sh
+npm run build && cargo build --manifest-path packages/desktop-host/engine/Cargo.toml
+env -u DISPLAY -u WAYLAND_DISPLAY DESKLINK_IOS_MAC=user@mac npm run test:ios --workspace @desklink/react-native
+```
+
+The Mac needs Xcode with an iOS simulator runtime, CocoaPods, node and
+[`axe`](https://github.com/cameroncooke/AXe) on its login `PATH`; everything
+the run builds or caches stays in `~/desklink-ios` there. The run creates a
+uniquely named simulator and deletes it during cleanup. For host desktop isolation, see the
+[private-lab guidance](../../README.md#develop). When the selected
+Xcode has no simulator platform, point `DESKLINK_IOS_XCODE` at one that does;
+`DESKLINK_IOS_RUNTIME` picks the iOS version (for example `18.6`); the
+script's header lists the other settings. To capture the cursor tip proof, set
+`DESKLINK_IOS_POINTER_PROOF=before` or `after`; the run writes a 4x crop, device
+frame, proof metadata, and host click log under `DESKLINK_IOS_OUT`. Set
+`DESKLINK_IOS_APP` to reuse an app bundle under `DESKLINK_IOS_DIR` when running
+with `DESKLINK_IOS_SKIP_BUILD=1`. Run once with `before` before the change and
+once with `after` after it, on both iPhone and iPad simulators, to compare the
+pointer crop and verify the host click is within two desktop pixels of the tip.
+To try the example by hand against any bridge:
+
+```sh
+xcrun simctl launch <device> dev.desklink.example -desklinkUrl 'ws://HOST:PORT/desktop?token=TOKEN'
+```
+
 ## Licence
 
 Apache-2.0. See `NOTICE`.

package/app.plugin.js

@@ -0,0 +1,16 @@
+/**
+ * Opt-in config plugin: an iPad trackpad's or mouse's presses reach the
+ * desktop with the button that made them — a drag selects, a secondary click
+ * is a right click. It sets `UIApplicationSupportsIndirectInputEvents`, which
+ * changes how every screen of the app receives that input, so the package
+ * never sets it on its own. Hover, scroll and the hardware keyboard work
+ * without it.
+ *
+ *   "plugins": ["@desklink/react-native"]
+ */
+module.exports = function withDesklinkPointer(config) {
+    return {
+        ...config,
+        ios: { ...config.ios, infoPlist: { ...config.ios?.infoPlist, UIApplicationSupportsIndirectInputEvents: true } },
+    };
+};

package/expo-module.config.json

@@ -1,6 +1,9 @@
 {
-  "platforms": ["android"],
+  "platforms": ["android", "ios"],
   "android": {
     "modules": ["expo.modules.desklink.DesklinkModule"]
+  },
+  "ios": {
+    "modules": ["DesklinkInputModule"]
   }
 }

package/ios/DesklinkInput.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'DesklinkInput'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = 'desklink'
+  s.homepage       = 'https://github.com/umeranjum17/desklink'
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/umeranjum17/desklink.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
+  s.source_files = '*.swift'
+end

package/ios/DesklinkInputModule.swift

@@ -0,0 +1,20 @@
+import ExpoModulesCore
+
+/**
+ * The iOS view's hardware input: the keys and the pointer React Native's touch
+ * system cannot see. The session, the picture and touch gestures stay in
+ * JavaScript; this module only reports what UIKit delivers.
+ */
+public final class DesklinkInputModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("DesklinkInput")
+
+    View(DesklinkInputView.self) {
+      Events("onKey", "onPointer", "onWheel")
+
+      Prop("enabled") { (view: DesklinkInputView, enabled: Bool) in
+        view.enabled = enabled
+      }
+    }
+  }
+}

package/ios/DesklinkInputView.swift

@@ -0,0 +1,209 @@
+import ExpoModulesCore
+import UIKit
+
+/**
+ * The desktop surface on iOS: the view around the picture and the hidden text
+ * field, reporting the input React Native's touch system never sees.
+ *
+ * Keys: while control is enabled this view is the first responder, so a
+ * hardware keyboard's presses arrive here with their down and up — arrows,
+ * Esc, Tab and Command chords a text field does not report. The hidden text
+ * field takes over while the app shows the on-screen keyboard; keys it does not
+ * use still bubble up to this view, and the view takes the keyboard back when
+ * the field lets go.
+ *
+ * Pointer: an iPad trackpad or mouse hovering the view and its scroll. Its
+ * presses arrive with the button that made them only once the app sets
+ * `UIApplicationSupportsIndirectInputEvents` (the package's config plugin);
+ * until then UIKit hands them to React Native as touches.
+ */
+final class DesklinkInputView: ExpoView {
+  let onKey = EventDispatcher()
+  let onPointer = EventDispatcher()
+  let onWheel = EventDispatcher()
+
+  var enabled = false {
+    didSet {
+      guard enabled != oldValue else { return }
+      if enabled {
+        takeKeyboard(fromTouch: false)
+      } else {
+        releaseKeys()
+        if isFirstResponder { resignFirstResponder() }
+      }
+    }
+  }
+
+  /** Keys pressed here and not yet released, so none stays down on the desktop. */
+  private var held: [UIKeyboardHIDUsage: UIKey] = [:]
+
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    addGestureRecognizer(UIHoverGestureRecognizer(target: self, action: #selector(hovered(_:))))
+    // A trackpad's or wheel's scroll only: touches stay with React Native.
+    let scroll = UIPanGestureRecognizer(target: self, action: #selector(scrolled(_:)))
+    scroll.allowedScrollTypesMask = .all
+    scroll.allowedTouchTypes = []
+    addGestureRecognizer(scroll)
+    NotificationCenter.default.addObserver(
+      self, selector: #selector(editingEnded(_:)), name: UITextField.textDidEndEditingNotification, object: nil)
+  }
+
+  // MARK: - Keyboard focus
+
+  override var canBecomeFirstResponder: Bool { enabled }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil { releaseKeys() } else { takeKeyboard(fromTouch: false) }
+  }
+
+  override func resignFirstResponder() -> Bool {
+    let resigned = super.resignFirstResponder()
+    if resigned { releaseKeys() }
+    return resigned
+  }
+
+  /**
+   * Become the keyboard's target. On its own the view never takes the keyboard
+   * from a responder that has it — another field of the app, say. A touch on
+   * the desktop does, like a tap on any field, except from the view's own text
+   * field, which keeps the on-screen keyboard up.
+   */
+  private func takeKeyboard(fromTouch: Bool) {
+    guard enabled, window != nil, !isFirstResponder else { return }
+    if let current = DesklinkInputView.currentFirstResponder() {
+      if !fromTouch { return }
+      if let view = current as? UIView, view.isDescendant(of: self) { return }
+    }
+    becomeFirstResponder()
+  }
+
+  @objc private func editingEnded(_ notification: Notification) {
+    guard let field = notification.object as? UIView, field.isDescendant(of: self) else { return }
+    // Once the field has let go, the keyboard comes back to the desktop.
+    DispatchQueue.main.async { [weak self] in self?.takeKeyboard(fromTouch: false) }
+  }
+
+  fileprivate static weak var found: UIResponder?
+
+  static func currentFirstResponder() -> UIResponder? {
+    found = nil
+    UIApplication.shared.sendAction(#selector(UIResponder.desklinkReportFirstResponder), to: nil, from: nil, for: nil)
+    // With no first responder the action ends at the application itself.
+    return found?.isFirstResponder == true ? found : nil
+  }
+
+  // MARK: - Keys
+
+  override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+    var rest = Set<UIPress>()
+    for press in presses {
+      guard enabled, let key = press.key else { rest.insert(press); continue }
+      held[key.keyCode] = key
+      report(key, down: true)
+    }
+    if !rest.isEmpty { super.pressesBegan(rest, with: event) }
+  }
+
+  override func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+    let rest = release(presses)
+    if !rest.isEmpty { super.pressesEnded(rest, with: event) }
+  }
+
+  override func pressesCancelled(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+    let rest = release(presses)
+    if !rest.isEmpty { super.pressesCancelled(rest, with: event) }
+  }
+
+  /** Report the keys among `presses` that went down here; the rest belong to someone else. */
+  private func release(_ presses: Set<UIPress>) -> Set<UIPress> {
+    var rest = Set<UIPress>()
+    for press in presses {
+      guard let key = press.key, held.removeValue(forKey: key.keyCode) != nil else { rest.insert(press); continue }
+      report(key, down: false)
+    }
+    return rest
+  }
+
+  /** Let go of every key still down: the desktop must not keep one held. */
+  private func releaseKeys() {
+    for key in held.values { report(key, down: false) }
+    held.removeAll()
+  }
+
+  /** The key's HID usage and the characters it types; JavaScript names it. Command is the desktop's Meta. */
+  private func report(_ key: UIKey, down: Bool) {
+    var modifiers: [String] = []
+    if key.modifierFlags.contains(.control) { modifiers.append("Control") }
+    if key.modifierFlags.contains(.alternate) { modifiers.append("Alt") }
+    if key.modifierFlags.contains(.command) { modifiers.append("Meta") }
+    if key.modifierFlags.contains(.shift) { modifiers.append("Shift") }
+    onKey(["down": down, "usage": key.keyCode.rawValue, "characters": key.characters, "modifiers": modifiers])
+  }
+
+  // MARK: - Pointer
+
+  override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+    super.touchesBegan(touches, with: event)
+    guard enabled else { return }
+    takeKeyboard(fromTouch: true)
+    report(touches, phase: "down", event)
+  }
+
+  override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
+    super.touchesMoved(touches, with: event)
+    if enabled { report(touches, phase: "move", event) }
+  }
+
+  override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+    super.touchesEnded(touches, with: event)
+    if enabled { report(touches, phase: "up", event) }
+  }
+
+  override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
+    super.touchesCancelled(touches, with: event)
+    if enabled { report(touches, phase: "cancel", event) }
+  }
+
+  /**
+   * A press of a trackpad or mouse with the button that made it. The touch's
+   * timestamp is the one React Native reports for the same touch, so the view
+   * can tell this press from a finger.
+   */
+  private func report(_ touches: Set<UITouch>, phase: String, _ event: UIEvent?) {
+    for touch in touches where touch.type == .indirectPointer {
+      let at = touch.location(in: self)
+      onPointer([
+        "phase": phase, "x": at.x, "y": at.y,
+        "buttons": event?.buttonMask.rawValue ?? 0, "timestamp": touch.timestamp * 1000,
+      ])
+    }
+  }
+
+  @objc private func hovered(_ recognizer: UIHoverGestureRecognizer) {
+    guard enabled, recognizer.state == .began || recognizer.state == .changed else { return }
+    let at = recognizer.location(in: self)
+    onPointer(["phase": "hover", "x": at.x, "y": at.y])
+  }
+
+  @objc private func scrolled(_ recognizer: UIPanGestureRecognizer) {
+    guard enabled else { return }
+    let at = recognizer.location(in: self)
+    let moved = recognizer.translation(in: self)
+    recognizer.setTranslation(.zero, in: self)
+    let phase: String
+    switch recognizer.state {
+    case .began: phase = "begin"
+    case .changed: phase = "move"
+    default: phase = "end"
+    }
+    onWheel(["phase": phase, "dx": moved.x, "dy": moved.y, "x": at.x, "y": at.y])
+  }
+}
+
+extension UIResponder {
+  @objc fileprivate func desklinkReportFirstResponder() {
+    DesklinkInputView.found = self
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/react-native",
-    "version": "0.2.0",
+    "version": "0.3.1",
     "license": "Apache-2.0",
     "description": "Render and drive a desktop session from a React Native app",
     "main": "index.ts",
@@ -10,7 +10,9 @@
         "./availability": {
             "browser": "./src/availability.web.ts",
             "default": "./src/availability.ts"
-        }
+        },
+        "./app.plugin.js": "./app.plugin.js",
+        "./package.json": "./package.json"
     },
     "files": [
         "index.ts",
@@ -19,6 +21,9 @@
         "android/build.gradle",
         "android/gradle.properties",
         "android/src/main",
+        "ios/*.swift",
+        "ios/*.podspec",
+        "app.plugin.js",
         "expo-module.config.json",
         "NOTICE",
         "README.md"
@@ -31,6 +36,7 @@
         "react-native-webrtc": ">=124"
     },
     "scripts": {
-        "test:reconnect": "node test/reconnect-flow.mjs"
+        "test:reconnect": "node test/reconnect-flow.mjs",
+        "test:ios": "node test/ios-flow.mjs"
     }
 }