iPhone client for network-computer: see and drive a remote Linux/Mac desktop over WebRTC, phone as trackpad and keyboard, desktop on a TV via AirPlay.

0 downloads

network-computer-ios/Sources/Session/SessionStore.swift
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/network-computer-ios.git
HTTPS
https://gitstable.com/git/askrobots/network-computer-ios.git
SSH
ssh://git@gitstable.com:2222/askrobots/network-computer-ios.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

Dan Quellhorst First cut of the iPhone client cc1f67f 2 months ago History
SessionStore.swift · 3.9 KB · 105 lines
1import Foundation
2import Combine
3import WebRTC
4
5/// App-wide session state: the one place the UI, the trackpad and the external
6/// display look for the current connection.
7@MainActor
8final class SessionStore: ObservableObject {
9 static let shared = SessionStore()
10
11 enum State: Equatable { case idle, connecting(String), connected, failed(String) }
12
13 @Published var state: State = .idle
14 @Published var hosts: [String] = []
15 @Published var videoTrack: RTCVideoTrack?
16 @Published var stats = PeerClient.Stats()
17 @Published var externalDisplayConnected = false
18 var externalRenderer: RTCVideoRenderer?
19
20 private var signaling: SignalingClient?
21 private var peer: PeerClient?
22
23 var isConnected: Bool { state == .connected }
24
25 func refreshHosts() async {
26 guard let ep = Settings.shared.endpoint else { state = .failed("Bad rendezvous URL"); return }
27 do {
28 hosts = try await SignalingClient(endpoint: ep).fetchHosts()
29 if Settings.shared.hostName.isEmpty, let first = hosts.first { Settings.shared.hostName = first }
30 if case .failed = state { state = .idle }
31 } catch {
32 state = .failed(error.localizedDescription)
33 }
34 }
35
36 func connect() async {
37 let s = Settings.shared
38 guard let ep = s.endpoint else { state = .failed("Bad rendezvous URL"); return }
39 guard !s.hostName.isEmpty else { state = .failed("Pick a host"); return }
40 disconnect()
41 state = .connecting("fetching config")
42 do {
43 let sig = SignalingClient(endpoint: ep)
44 let cfg = try await sig.fetchConfig()
45 let peer = PeerClient(iceServers: cfg.iceServers, relayOnly: s.relayOnly)
46 self.peer = peer
47 self.signaling = sig
48 let host = s.hostName
49
50 peer.onVideoTrack = { [weak self] track in
51 self?.videoTrack = track
52 if let r = self?.externalRenderer { track.add(r) }
53 }
54 peer.onIceCandidate = { [weak sig] c in
55 sig?.send(SignalMessage(type: "ice", to: host, candidate: c))
56 }
57 peer.onState = { [weak self] st in
58 guard let self else { return }
59 switch st {
60 case .connected: self.state = .connected
61 case .failed: self.state = .failed("Connection failed")
62 case .disconnected, .closed: if self.state == .connected { self.state = .failed("Disconnected") }
63 default: break
64 }
65 }
66 peer.onStats = { [weak self] st in self?.stats = st }
67
68 sig.onMessage = { [weak self] m in
69 Task { @MainActor in
70 switch m.type {
71 case "answer": if let sdp = m.sdp { try? await peer.setAnswer(sdp) }
72 case "ice": if let c = m.candidate { peer.addCandidate(c) }
73 case "error": self?.state = .failed(m.error ?? "rendezvous error"); self?.disconnect()
74 default: break
75 }
76 }
77 }
78 sig.onClose = { [weak self] _ in
79 Task { @MainActor in
80 if case .connecting = self?.state ?? .idle { self?.state = .failed("Signaling closed") }
81 }
82 }
83
84 state = .connecting("signaling")
85 sig.connect()
86 let sdp = try await peer.createOffer()
87 sig.send(SignalMessage(type: "offer", to: host, sdp: sdp, pin: s.pin))
88 state = .connecting("waiting for \(host)")
89 } catch {
90 state = .failed(error.localizedDescription)
91 disconnect()
92 }
93 }
94
95 func disconnect() {
96 peer?.close()
97 peer = nil
98 signaling?.close()
99 signaling = nil
100 videoTrack = nil
101 if state == .connected { state = .idle }
102 }
103
104 func send(_ e: InputEvent) { peer?.send(e) }
105}