Compare commits
17 Commits
d20bb2fef4
...
db3873b29e
| Author | SHA1 | Date |
|---|---|---|
 Laurent
|
db3873b29e | 1 month ago |
|
Laurent
|
d17dac287d | 1 month ago |
|
Laurent
|
4b256f7811 | 1 month ago |
|
Laurent
|
4ee0325d2f | 1 month ago |
|
Laurent
|
fb76901366 | 1 month ago |
|
Laurent
|
4bf1a5e4ef | 1 month ago |
|
Laurent
|
463ecb518b | 1 month ago |
|
Laurent
|
e5b5c249b4 | 1 month ago |
|
Laurent
|
4fa431e9bd | 1 month ago |
|
Laurent
|
c3b97eb201 | 1 month ago |
|
Laurent
|
c754858f21 | 1 month ago |
|
Laurent
|
b0359f127b | 1 month ago |
|
Laurent
|
89d50e6e94 | 1 month ago |
|
Laurent
|
6005ce739f | 1 month ago |
|
Laurent
|
5320da4b82 | 1 month ago |
|
Laurent
|
0eaa095bae | 1 month ago |
|
Laurent
|
2f1b9b537c | 1 month ago |
@ -0,0 +1,69 @@ |
|||||||
|
import Foundation |
||||||
|
|
||||||
|
/// Represents the connection lifecycle of the remote client. |
||||||
|
/// Transitions are validated by `canTransition(to:)` to enforce a strict state machine. |
||||||
|
nonisolated enum ConnectionState: Equatable, Sendable { |
||||||
|
case disconnected |
||||||
|
case discovering |
||||||
|
case foundHost(String) |
||||||
|
case downloadingDB |
||||||
|
case connectingCommandChannel |
||||||
|
case connected(String) |
||||||
|
case connectionLost(String) |
||||||
|
|
||||||
|
/// Human-readable status message for display in the UI. |
||||||
|
var userMessage: String? { |
||||||
|
switch self { |
||||||
|
case .disconnected: |
||||||
|
nil |
||||||
|
case .discovering: |
||||||
|
"Searching for hosts..." |
||||||
|
case .foundHost(let host): |
||||||
|
"Found \(host)" |
||||||
|
case .downloadingDB: |
||||||
|
"Downloading library..." |
||||||
|
case .connectingCommandChannel: |
||||||
|
"Connecting..." |
||||||
|
case .connected(let host): |
||||||
|
"Connected to \(host)" |
||||||
|
case .connectionLost(let reason): |
||||||
|
"Connection lost — \(reason)" |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Whether the client is fully connected. |
||||||
|
var isConnected: Bool { |
||||||
|
if case .connected = self { return true } |
||||||
|
return false |
||||||
|
} |
||||||
|
|
||||||
|
/// Validates whether transitioning from the current state to `next` is allowed. |
||||||
|
/// |
||||||
|
/// Valid forward transitions follow the connection lifecycle: |
||||||
|
/// disconnected → discovering → foundHost → downloadingDB → connectingCommandChannel → connected → connectionLost → discovering |
||||||
|
/// |
||||||
|
/// Any state may transition to `.disconnected` (the user can always disconnect). |
||||||
|
func canTransition(to next: ConnectionState) -> Bool { |
||||||
|
// Any state can go to disconnected |
||||||
|
if case .disconnected = next { return true } |
||||||
|
|
||||||
|
switch self { |
||||||
|
case .disconnected: |
||||||
|
if case .discovering = next { return true } |
||||||
|
case .discovering: |
||||||
|
if case .foundHost = next { return true } |
||||||
|
case .foundHost: |
||||||
|
if case .downloadingDB = next { return true } |
||||||
|
case .downloadingDB: |
||||||
|
if case .connectingCommandChannel = next { return true } |
||||||
|
case .connectingCommandChannel: |
||||||
|
if case .connected = next { return true } |
||||||
|
case .connected: |
||||||
|
if case .connectionLost = next { return true } |
||||||
|
case .connectionLost: |
||||||
|
if case .discovering = next { return true } |
||||||
|
} |
||||||
|
|
||||||
|
return false |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,363 @@ |
|||||||
|
import Foundation |
||||||
|
import Network |
||||||
|
import os |
||||||
|
|
||||||
|
@MainActor |
||||||
|
@Observable |
||||||
|
final class HostServer { |
||||||
|
var isHosting = false |
||||||
|
var connectedRemoteName: String? |
||||||
|
private(set) var actualPort: UInt16? |
||||||
|
|
||||||
|
private let dbPath: String |
||||||
|
private var listener: NWListener? |
||||||
|
private var commandTransport: NDJSONTransport? |
||||||
|
private var commandConnection: NWConnection? |
||||||
|
private var player: PlayerViewModel? |
||||||
|
private var db: DatabaseService? |
||||||
|
private var stateTimer: Timer? |
||||||
|
|
||||||
|
private let logger = RemoteLogger.host |
||||||
|
|
||||||
|
init(dbPath: String) { |
||||||
|
self.dbPath = dbPath |
||||||
|
} |
||||||
|
|
||||||
|
/// Configure the server with a player and database for command dispatch. |
||||||
|
/// Pass `nil` for either if not needed (e.g. DB-only serving without a player). |
||||||
|
func configure(player: PlayerViewModel?, db: DatabaseService?) { |
||||||
|
self.player = player |
||||||
|
self.db = db |
||||||
|
} |
||||||
|
|
||||||
|
/// Start the Bonjour listener on a random TCP port. |
||||||
|
func start() throws { |
||||||
|
let params = NWParameters.tcp |
||||||
|
let listener = try NWListener(using: params) |
||||||
|
listener.service = NWListener.Service(type: "_musicremote._tcp") |
||||||
|
|
||||||
|
listener.stateUpdateHandler = { [weak self] state in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
switch state { |
||||||
|
case .ready: |
||||||
|
if let port = listener.port?.rawValue { |
||||||
|
self.actualPort = port |
||||||
|
self.logger.info("Listener ready on port \(port)") |
||||||
|
} |
||||||
|
self.isHosting = true |
||||||
|
case .failed(let error): |
||||||
|
self.logger.error("Listener failed: \(error.localizedDescription)") |
||||||
|
self.isHosting = false |
||||||
|
case .cancelled: |
||||||
|
self.isHosting = false |
||||||
|
default: |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
listener.newConnectionHandler = { [weak self] connection in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
self?.handleNewConnection(connection) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
listener.start(queue: .main) |
||||||
|
self.listener = listener |
||||||
|
|
||||||
|
// Start periodic playback-state timer |
||||||
|
stateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
self?.sendPlaybackState() |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Stop the server, close all connections, and remove the Bonjour advertisement. |
||||||
|
func stop() { |
||||||
|
stateTimer?.invalidate() |
||||||
|
stateTimer = nil |
||||||
|
commandTransport?.close() |
||||||
|
commandTransport = nil |
||||||
|
commandConnection?.cancel() |
||||||
|
commandConnection = nil |
||||||
|
connectedRemoteName = nil |
||||||
|
listener?.cancel() |
||||||
|
listener = nil |
||||||
|
actualPort = nil |
||||||
|
isHosting = false |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Connection Handling |
||||||
|
|
||||||
|
/// Receive the first chunk of data from a new connection to determine the HTTP route. |
||||||
|
private func handleNewConnection(_ connection: NWConnection) { |
||||||
|
connection.stateUpdateHandler = { [weak self] state in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
if case .failed(let error) = state { |
||||||
|
self?.logger.error("Connection failed: \(error.localizedDescription)") |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
connection.start(queue: .main) |
||||||
|
|
||||||
|
// Read the initial HTTP request line to determine the route |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 65_536) { [weak self] data, _, _, error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
|
||||||
|
if let error { |
||||||
|
self.logger.error("Failed to read request: \(error.localizedDescription)") |
||||||
|
connection.cancel() |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
guard let data, let request = String(data: data, encoding: .utf8) else { |
||||||
|
connection.cancel() |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
self.routeRequest(request, on: connection) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Parse the HTTP request line and dispatch to the appropriate handler. |
||||||
|
private func routeRequest(_ request: String, on connection: NWConnection) { |
||||||
|
let firstLine = request.split(separator: "\r\n").first.map(String.init) ?? request |
||||||
|
logger.info("Request: \(firstLine)") |
||||||
|
|
||||||
|
if firstLine.hasPrefix("GET /db") { |
||||||
|
handleDBRequest(on: connection) |
||||||
|
} else if firstLine.hasPrefix("GET /cmd") { |
||||||
|
handleCommandRequest(on: connection) |
||||||
|
} else { |
||||||
|
sendHTTP(status: "404 Not Found", body: Data("Not Found".utf8), on: connection, close: true) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - GET /db |
||||||
|
|
||||||
|
/// Serve the SQLite database as an HTTP response. |
||||||
|
/// Uses SQLite's backup API to produce a self-contained copy that includes |
||||||
|
/// all WAL data, avoiding races with concurrent writers. |
||||||
|
private func handleDBRequest(on connection: NWConnection) { |
||||||
|
do { |
||||||
|
let data: Data |
||||||
|
if let db { |
||||||
|
// Create a temporary copy via the backup API so the served file |
||||||
|
// is self-contained (no WAL/SHM dependency) and consistent. |
||||||
|
let tempURL = FileManager.default.temporaryDirectory |
||||||
|
.appendingPathComponent(UUID().uuidString + ".sqlite") |
||||||
|
defer { try? FileManager.default.removeItem(at: tempURL) } |
||||||
|
try db.backup(to: tempURL.path) |
||||||
|
data = try Data(contentsOf: tempURL) |
||||||
|
} else { |
||||||
|
// Fallback: serve the raw file when no DatabaseService is configured |
||||||
|
data = try Data(contentsOf: URL(fileURLWithPath: dbPath)) |
||||||
|
} |
||||||
|
logger.info("Serving database (\(data.count) bytes)") |
||||||
|
sendHTTP( |
||||||
|
status: "200 OK", |
||||||
|
body: data, |
||||||
|
contentType: "application/octet-stream", |
||||||
|
on: connection, |
||||||
|
close: true |
||||||
|
) |
||||||
|
} catch { |
||||||
|
logger.error("Failed to read database: \(error.localizedDescription)") |
||||||
|
sendHTTP( |
||||||
|
status: "500 Internal Server Error", |
||||||
|
body: Data("Failed to read database".utf8), |
||||||
|
on: connection, |
||||||
|
close: true |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - GET /cmd |
||||||
|
|
||||||
|
/// Upgrade the connection to an NDJSON command channel. |
||||||
|
private func handleCommandRequest(on connection: NWConnection) { |
||||||
|
// Only one command channel at a time |
||||||
|
if commandTransport != nil { |
||||||
|
logger.warning("Rejecting second command channel") |
||||||
|
sendHTTP( |
||||||
|
status: "409 Conflict", |
||||||
|
body: Data("Command channel already connected".utf8), |
||||||
|
on: connection, |
||||||
|
close: true |
||||||
|
) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Send the HTTP 200 response header, then upgrade to NDJSON streaming |
||||||
|
let header = "HTTP/1.1 200 OK\r\nContent-Type: application/x-ndjson\r\nTransfer-Encoding: chunked\r\nConnection: keep-alive\r\n\r\n" |
||||||
|
connection.send(content: Data(header.utf8), completion: .contentProcessed { [weak self] error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
|
||||||
|
if let error { |
||||||
|
self.logger.error("Failed to send cmd header: \(error.localizedDescription)") |
||||||
|
connection.cancel() |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
self.setupCommandTransport(on: connection) |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
/// Wire up the NDJSON transport for reading commands and sending events. |
||||||
|
private func setupCommandTransport(on connection: NWConnection) { |
||||||
|
let transport = NDJSONTransport(connection: connection, logger: logger) |
||||||
|
self.commandTransport = transport |
||||||
|
self.commandConnection = connection |
||||||
|
|
||||||
|
transport.onLine = { [weak self] line in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
self?.handleIncomingLine(line) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
transport.onClose = { [weak self] in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
self.logger.info("Command channel closed") |
||||||
|
self.commandTransport = nil |
||||||
|
self.commandConnection = nil |
||||||
|
self.connectedRemoteName = nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
transport.startReceiving() |
||||||
|
logger.info("Command channel established") |
||||||
|
|
||||||
|
// Send initial playback state |
||||||
|
sendPlaybackState() |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Command Dispatch |
||||||
|
|
||||||
|
/// Process an incoming NDJSON line — try handshake first, then remote command. |
||||||
|
private func handleIncomingLine(_ line: String) { |
||||||
|
guard let data = line.data(using: .utf8) else { return } |
||||||
|
let decoder = JSONDecoder() |
||||||
|
|
||||||
|
// Try parsing as a handshake message first |
||||||
|
if let handshake = try? decoder.decode(HandshakeMessage.self, from: data) { |
||||||
|
logger.info("Handshake received: v\(handshake.protocolVersion), app \(handshake.appVersion)") |
||||||
|
connectedRemoteName = handshake.appVersion |
||||||
|
sendPlaybackState() |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Parse as a remote command |
||||||
|
do { |
||||||
|
let command = try decoder.decode(RemoteCommand.self, from: data) |
||||||
|
logger.info("Received command: \(String(describing: command))") |
||||||
|
dispatchCommand(command) |
||||||
|
} catch { |
||||||
|
logger.error("Failed to decode command: \(error.localizedDescription)") |
||||||
|
commandTransport?.send(HostEvent.error(message: "Invalid command")) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Execute the remote command against the player. |
||||||
|
private func dispatchCommand(_ command: RemoteCommand) { |
||||||
|
guard let player else { |
||||||
|
logger.warning("No player configured, ignoring command") |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
switch command { |
||||||
|
case .play(let trackId, let queueIds): |
||||||
|
handlePlayCommand(trackId: trackId, queueIds: queueIds, player: player) |
||||||
|
case .pause: |
||||||
|
player.pause() |
||||||
|
case .resume: |
||||||
|
player.resume() |
||||||
|
case .next: |
||||||
|
player.next() |
||||||
|
case .previous: |
||||||
|
player.previous() |
||||||
|
case .seek(let position): |
||||||
|
player.seek(to: position) |
||||||
|
case .setVolume(let level): |
||||||
|
player.setVolume(level) |
||||||
|
case .toggleShuffle: |
||||||
|
player.toggleShuffle() |
||||||
|
case .refreshDB: |
||||||
|
commandTransport?.send(HostEvent.dbReady) |
||||||
|
return // Don't send playback state for refreshDB, just the dbReady event |
||||||
|
} |
||||||
|
|
||||||
|
// After each command, send current playback state |
||||||
|
sendPlaybackState() |
||||||
|
} |
||||||
|
|
||||||
|
/// Handle the play command by fetching tracks and setting up the queue. |
||||||
|
private func handlePlayCommand(trackId: Int64, queueIds: [Int64], player: PlayerViewModel) { |
||||||
|
guard let db else { |
||||||
|
logger.warning("No database configured, cannot handle play command") |
||||||
|
commandTransport?.send(HostEvent.error(message: "No database available")) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
do { |
||||||
|
let tracks = try db.fetchTracksByIds(queueIds) |
||||||
|
guard let track = tracks.first(where: { $0.id == trackId }) else { |
||||||
|
logger.warning("Track \(trackId) not found in database") |
||||||
|
commandTransport?.send(HostEvent.error(message: "Track not found")) |
||||||
|
return |
||||||
|
} |
||||||
|
player.setQueue(tracks) |
||||||
|
player.play(track) |
||||||
|
} catch { |
||||||
|
logger.error("Failed to fetch tracks: \(error.localizedDescription)") |
||||||
|
commandTransport?.send(HostEvent.error(message: "Database error")) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - State Updates |
||||||
|
|
||||||
|
/// Build and send the current playback state to the connected remote. |
||||||
|
private func sendPlaybackState() { |
||||||
|
guard let transport = commandTransport else { return } |
||||||
|
|
||||||
|
let payload = PlaybackStatePayload( |
||||||
|
trackId: player?.currentTrack?.id, |
||||||
|
isPlaying: player?.isPlaying ?? false, |
||||||
|
currentTime: player?.currentTime ?? 0, |
||||||
|
duration: player?.duration ?? 0, |
||||||
|
volume: player?.volume ?? 0.65, |
||||||
|
isShuffled: player?.isShuffled ?? false |
||||||
|
) |
||||||
|
|
||||||
|
transport.send(HostEvent.playbackState(payload)) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - HTTP Helper |
||||||
|
|
||||||
|
/// Send an HTTP response with the given status, body, and content type. |
||||||
|
private func sendHTTP( |
||||||
|
status: String, |
||||||
|
body: Data?, |
||||||
|
contentType: String = "text/plain", |
||||||
|
on connection: NWConnection, |
||||||
|
close: Bool |
||||||
|
) { |
||||||
|
let bodyData = body ?? Data() |
||||||
|
let header = "HTTP/1.1 \(status)\r\nContent-Type: \(contentType)\r\nContent-Length: \(bodyData.count)\r\nConnection: \(close ? "close" : "keep-alive")\r\n\r\n" |
||||||
|
var responseData = Data(header.utf8) |
||||||
|
responseData.append(bodyData) |
||||||
|
|
||||||
|
connection.send(content: responseData, completion: .contentProcessed { _ in |
||||||
|
if close { |
||||||
|
connection.cancel() |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,32 @@ |
|||||||
|
import Foundation |
||||||
|
|
||||||
|
/// A pure, testable line-buffered parser. |
||||||
|
/// Receives arbitrary Data chunks, splits on newlines, emits complete lines via callback. |
||||||
|
final class NDJSONLineBuffer: @unchecked Sendable { |
||||||
|
private var buffer = "" |
||||||
|
private let onLine: (String) -> Void |
||||||
|
|
||||||
|
init(onLine: @escaping (String) -> Void) { |
||||||
|
self.onLine = onLine |
||||||
|
} |
||||||
|
|
||||||
|
/// Append data to the internal buffer and emit every complete line (delimited by `\n`). |
||||||
|
/// Partial lines are retained until the next `feed()` call completes them. |
||||||
|
func feed(_ data: Data) { |
||||||
|
guard let chunk = String(data: data, encoding: .utf8) else { return } |
||||||
|
buffer.append(chunk) |
||||||
|
|
||||||
|
while let newlineIndex = buffer.firstIndex(of: "\n") { |
||||||
|
let line = String(buffer[buffer.startIndex..<newlineIndex]) |
||||||
|
buffer = String(buffer[buffer.index(after: newlineIndex)...]) |
||||||
|
if !line.isEmpty { |
||||||
|
onLine(line) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Clear the internal buffer, discarding any incomplete line. |
||||||
|
func reset() { |
||||||
|
buffer = "" |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,88 @@ |
|||||||
|
import Foundation |
||||||
|
import Network |
||||||
|
import os |
||||||
|
|
||||||
|
/// Wraps an `NWConnection` for sending and receiving newline-delimited JSON messages. |
||||||
|
@MainActor |
||||||
|
final class NDJSONTransport { |
||||||
|
private let connection: NWConnection |
||||||
|
private let lineBuffer: NDJSONLineBuffer |
||||||
|
private let logger: os.Logger |
||||||
|
private let encoder: JSONEncoder = { |
||||||
|
let e = JSONEncoder() |
||||||
|
e.outputFormatting = [.sortedKeys] |
||||||
|
return e |
||||||
|
}() |
||||||
|
|
||||||
|
/// Called for each complete line received from the connection. |
||||||
|
var onLine: ((String) -> Void)? |
||||||
|
|
||||||
|
/// Called when the connection is closed or encounters an error. |
||||||
|
var onClose: (() -> Void)? |
||||||
|
|
||||||
|
init(connection: NWConnection, logger: os.Logger) { |
||||||
|
self.connection = connection |
||||||
|
self.logger = logger |
||||||
|
|
||||||
|
// Capture self weakly in the line buffer callback to avoid retain cycles. |
||||||
|
// The buffer is created before self is fully initialized, so we set the |
||||||
|
// actual forwarding closure after init completes via a two-phase approach. |
||||||
|
var forwardLine: ((String) -> Void)? |
||||||
|
self.lineBuffer = NDJSONLineBuffer { line in |
||||||
|
forwardLine?(line) |
||||||
|
} |
||||||
|
forwardLine = { [weak self] line in |
||||||
|
self?.onLine?(line) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// JSON-encode the message, append a newline, and send it over the connection. |
||||||
|
func send<T: Encodable>(_ message: T) { |
||||||
|
do { |
||||||
|
var data = try encoder.encode(message) |
||||||
|
data.append(contentsOf: [UInt8(ascii: "\n")]) |
||||||
|
connection.send(content: data, completion: .contentProcessed { [weak self] error in |
||||||
|
if let error { |
||||||
|
self?.logger.error("Send failed: \(error.localizedDescription)") |
||||||
|
} |
||||||
|
}) |
||||||
|
} catch { |
||||||
|
logger.error("Encode failed: \(error.localizedDescription)") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Begin the receive loop. Data is fed into the line buffer, which emits |
||||||
|
/// complete lines via the `onLine` callback. |
||||||
|
func startReceiving() { |
||||||
|
receiveNext() |
||||||
|
} |
||||||
|
|
||||||
|
/// Cancel the underlying connection. |
||||||
|
func close() { |
||||||
|
connection.cancel() |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Private |
||||||
|
|
||||||
|
private func receiveNext() { |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 65_536) { [weak self] content, _, isComplete, error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
|
||||||
|
if let data = content, !data.isEmpty { |
||||||
|
self.lineBuffer.feed(data) |
||||||
|
} |
||||||
|
|
||||||
|
if isComplete { |
||||||
|
self.logger.info("Connection closed by peer") |
||||||
|
self.onClose?() |
||||||
|
} else if let error { |
||||||
|
self.logger.error("Receive error: \(error.localizedDescription)") |
||||||
|
self.onClose?() |
||||||
|
} else { |
||||||
|
self.receiveNext() |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,17 @@ |
|||||||
|
import Foundation |
||||||
|
|
||||||
|
struct NetworkStatus { |
||||||
|
enum Mode { |
||||||
|
case hosting(connectedRemote: String?) |
||||||
|
case remote(hostName: String) |
||||||
|
} |
||||||
|
|
||||||
|
var mode: Mode |
||||||
|
var onDisconnect: (() -> Void)? |
||||||
|
var onRefreshLibrary: (() -> Void)? |
||||||
|
|
||||||
|
var isRemoteMode: Bool { |
||||||
|
if case .remote = mode { return true } |
||||||
|
return false |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,393 @@ |
|||||||
|
import Foundation |
||||||
|
import Network |
||||||
|
import os |
||||||
|
|
||||||
|
@MainActor |
||||||
|
@Observable |
||||||
|
final class RemoteClient: RemoteCommandSender { |
||||||
|
|
||||||
|
// MARK: - Public State |
||||||
|
|
||||||
|
var connectionState = ConnectionState.disconnected |
||||||
|
var discoveredHosts: [(name: String, endpoint: NWEndpoint)] = [] |
||||||
|
var onPlaybackState: ((PlaybackStatePayload) -> Void)? |
||||||
|
var onDBReady: (() -> Void)? |
||||||
|
|
||||||
|
// MARK: - Private State |
||||||
|
|
||||||
|
private var browser: NWBrowser? |
||||||
|
private var commandTransport: NDJSONTransport? |
||||||
|
private var hostEndpoint: NWEndpoint? |
||||||
|
private var pingTimer: Timer? |
||||||
|
private var missedPings = 0 |
||||||
|
|
||||||
|
private let logger = RemoteLogger.client |
||||||
|
|
||||||
|
// MARK: - Remote DB Path |
||||||
|
|
||||||
|
static var remoteDBPath: String { |
||||||
|
let appSupport = FileManager.default.urls( |
||||||
|
for: .applicationSupportDirectory, in: .userDomainMask |
||||||
|
).first!.appendingPathComponent("Music", isDirectory: true) |
||||||
|
return appSupport.appendingPathComponent("remote_db.sqlite").path |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Discovery |
||||||
|
|
||||||
|
/// Start scanning for `_musicremote._tcp` services on the local network. |
||||||
|
func startDiscovery() { |
||||||
|
let descriptor = NWBrowser.Descriptor.bonjour(type: "_musicremote._tcp", domain: nil) |
||||||
|
let browser = NWBrowser(for: descriptor, using: .tcp) |
||||||
|
|
||||||
|
browser.stateUpdateHandler = { [weak self] state in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
switch state { |
||||||
|
case .ready: |
||||||
|
self.logger.info("Browser ready") |
||||||
|
case .failed(let error): |
||||||
|
self.logger.error("Browser failed: \(error.localizedDescription)") |
||||||
|
case .cancelled: |
||||||
|
self.logger.info("Browser cancelled") |
||||||
|
default: |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
browser.browseResultsChangedHandler = { [weak self] results, _ in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
self.discoveredHosts = results.compactMap { result in |
||||||
|
if case .service(let name, _, _, _) = result.endpoint { |
||||||
|
return (name: name, endpoint: result.endpoint) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
self.logger.info("Discovered \(self.discoveredHosts.count) host(s)") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
browser.start(queue: .main) |
||||||
|
self.browser = browser |
||||||
|
transition(to: .discovering) |
||||||
|
} |
||||||
|
|
||||||
|
/// Stop scanning and clear discovered hosts. |
||||||
|
func stopDiscovery() { |
||||||
|
browser?.cancel() |
||||||
|
browser = nil |
||||||
|
discoveredHosts = [] |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Connection |
||||||
|
|
||||||
|
/// Connect to a discovered host: download its DB, then establish the command channel. |
||||||
|
func connect(to host: (name: String, endpoint: NWEndpoint)) { |
||||||
|
stopDiscovery() |
||||||
|
hostEndpoint = host.endpoint |
||||||
|
transition(to: .foundHost(host.name)) |
||||||
|
transition(to: .downloadingDB) |
||||||
|
downloadDatabase(on: host.endpoint, hostName: host.name) |
||||||
|
} |
||||||
|
|
||||||
|
/// Tear down everything: command channel, timers, and the local remote DB file. |
||||||
|
func disconnect() { |
||||||
|
pingTimer?.invalidate() |
||||||
|
pingTimer = nil |
||||||
|
missedPings = 0 |
||||||
|
commandTransport?.close() |
||||||
|
commandTransport = nil |
||||||
|
hostEndpoint = nil |
||||||
|
stopDiscovery() |
||||||
|
deleteRemoteDB() |
||||||
|
transition(to: .disconnected) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - RemoteCommandSender |
||||||
|
|
||||||
|
func sendCommand(_ command: RemoteCommand) { |
||||||
|
guard let transport = commandTransport else { |
||||||
|
logger.warning("Cannot send command — no command channel") |
||||||
|
return |
||||||
|
} |
||||||
|
transport.send(command) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - DB Download |
||||||
|
|
||||||
|
/// Open a TCP connection to the host, send `GET /db`, and save the response body to disk. |
||||||
|
private func downloadDatabase(on endpoint: NWEndpoint, hostName: String) { |
||||||
|
let connection = NWConnection(to: endpoint, using: .tcp) |
||||||
|
|
||||||
|
connection.stateUpdateHandler = { [weak self] state in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
switch state { |
||||||
|
case .ready: |
||||||
|
self.logger.info("DB connection ready") |
||||||
|
self.sendDBRequest(on: connection, hostName: hostName) |
||||||
|
case .failed(let error): |
||||||
|
self.logger.error("DB connection failed: \(error.localizedDescription)") |
||||||
|
self.transition(to: .disconnected) |
||||||
|
default: |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
connection.start(queue: .main) |
||||||
|
} |
||||||
|
|
||||||
|
/// Send the HTTP GET request for the database. |
||||||
|
private func sendDBRequest(on connection: NWConnection, hostName: String) { |
||||||
|
let request = "GET /db HTTP/1.1\r\nHost: \(hostName)\r\nConnection: close\r\n\r\n" |
||||||
|
connection.send(content: Data(request.utf8), completion: .contentProcessed { [weak self] error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
if let error { |
||||||
|
self.logger.error("Failed to send DB request: \(error.localizedDescription)") |
||||||
|
self.transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
self.receiveDBResponse(on: connection, accumulated: Data(), hostName: hostName) |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
/// Accumulate the full HTTP response for the DB download, then strip headers and save. |
||||||
|
private func receiveDBResponse(on connection: NWConnection, accumulated: Data, hostName: String) { |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 1_048_576) { [weak self] data, _, isComplete, error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
|
||||||
|
var buffer = accumulated |
||||||
|
if let data { |
||||||
|
buffer.append(data) |
||||||
|
} |
||||||
|
|
||||||
|
if isComplete || error != nil { |
||||||
|
// Done receiving — extract body after HTTP headers |
||||||
|
connection.cancel() |
||||||
|
self.handleDBData(buffer, hostName: hostName) |
||||||
|
} else { |
||||||
|
// Keep reading |
||||||
|
self.receiveDBResponse(on: connection, accumulated: buffer, hostName: hostName) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Strip the HTTP headers from the response and write the SQLite body to disk. |
||||||
|
private func handleDBData(_ data: Data, hostName: String) { |
||||||
|
// Find the header/body separator: \r\n\r\n |
||||||
|
let separator: [UInt8] = [0x0D, 0x0A, 0x0D, 0x0A] |
||||||
|
guard let separatorRange = data.range(of: Data(separator)) else { |
||||||
|
logger.error("DB response missing HTTP header separator") |
||||||
|
transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
let body = data[separatorRange.upperBound...] |
||||||
|
guard !body.isEmpty else { |
||||||
|
logger.error("DB response body is empty") |
||||||
|
transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Ensure the directory exists |
||||||
|
let dirURL = URL(fileURLWithPath: Self.remoteDBPath).deletingLastPathComponent() |
||||||
|
try? FileManager.default.createDirectory(at: dirURL, withIntermediateDirectories: true) |
||||||
|
|
||||||
|
do { |
||||||
|
try body.write(to: URL(fileURLWithPath: Self.remoteDBPath)) |
||||||
|
logger.info("Database saved (\(body.count) bytes) to \(Self.remoteDBPath)") |
||||||
|
connectCommandChannel(hostName: hostName) |
||||||
|
} catch { |
||||||
|
logger.error("Failed to write DB: \(error.localizedDescription)") |
||||||
|
transition(to: .disconnected) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Command Channel |
||||||
|
|
||||||
|
/// Open a second TCP connection to the same endpoint and upgrade it to the command channel. |
||||||
|
private func connectCommandChannel(hostName: String) { |
||||||
|
guard let endpoint = hostEndpoint else { |
||||||
|
logger.error("No endpoint stored for command channel") |
||||||
|
transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
transition(to: .connectingCommandChannel) |
||||||
|
|
||||||
|
let connection = NWConnection(to: endpoint, using: .tcp) |
||||||
|
|
||||||
|
connection.stateUpdateHandler = { [weak self] state in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
switch state { |
||||||
|
case .ready: |
||||||
|
self.logger.info("Command channel TCP ready") |
||||||
|
self.sendCmdRequest(on: connection, hostName: hostName) |
||||||
|
case .failed(let error): |
||||||
|
self.logger.error("Command channel connection failed: \(error.localizedDescription)") |
||||||
|
self.transition(to: .disconnected) |
||||||
|
default: |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
connection.start(queue: .main) |
||||||
|
} |
||||||
|
|
||||||
|
/// Send the HTTP GET request to upgrade to the command channel. |
||||||
|
private func sendCmdRequest(on connection: NWConnection, hostName: String) { |
||||||
|
let request = "GET /cmd HTTP/1.1\r\nHost: \(hostName)\r\nConnection: keep-alive\r\n\r\n" |
||||||
|
connection.send(content: Data(request.utf8), completion: .contentProcessed { [weak self] error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
if let error { |
||||||
|
self.logger.error("Failed to send cmd request: \(error.localizedDescription)") |
||||||
|
self.transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
self.receiveCmdHeader(on: connection, accumulated: Data(), hostName: hostName) |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
/// Read the HTTP 200 response header before upgrading to NDJSON streaming. |
||||||
|
private func receiveCmdHeader(on connection: NWConnection, accumulated: Data, hostName: String) { |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 65_536) { [weak self] data, _, _, error in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
|
||||||
|
if let error { |
||||||
|
self.logger.error("Failed to read cmd header: \(error.localizedDescription)") |
||||||
|
self.transition(to: .disconnected) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
var buffer = accumulated |
||||||
|
if let data { |
||||||
|
buffer.append(data) |
||||||
|
} |
||||||
|
|
||||||
|
// Check if we've received the full HTTP header |
||||||
|
let separator: [UInt8] = [0x0D, 0x0A, 0x0D, 0x0A] |
||||||
|
if buffer.range(of: Data(separator)) != nil { |
||||||
|
self.commandChannelReady(connection: connection, hostName: hostName) |
||||||
|
} else { |
||||||
|
// Keep reading until we get the full header |
||||||
|
self.receiveCmdHeader(on: connection, accumulated: buffer, hostName: hostName) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// The command channel HTTP handshake is complete — set up NDJSON transport. |
||||||
|
private func commandChannelReady(connection: NWConnection, hostName: String) { |
||||||
|
let transport = NDJSONTransport(connection: connection, logger: logger) |
||||||
|
self.commandTransport = transport |
||||||
|
|
||||||
|
transport.onLine = { [weak self] line in |
||||||
|
self?.handleEventLine(line) |
||||||
|
} |
||||||
|
|
||||||
|
transport.onClose = { [weak self] in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
self.logger.info("Command channel closed by host") |
||||||
|
self.pingTimer?.invalidate() |
||||||
|
self.pingTimer = nil |
||||||
|
self.commandTransport = nil |
||||||
|
if self.connectionState.isConnected { |
||||||
|
self.transition(to: .connectionLost("Host closed connection")) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
transport.startReceiving() |
||||||
|
|
||||||
|
// Send handshake |
||||||
|
let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown" |
||||||
|
let handshake = HandshakeMessage(protocolVersion: RemoteProtocolVersion, appVersion: appVersion) |
||||||
|
transport.send(handshake) |
||||||
|
|
||||||
|
// Start keep-alive ping timer |
||||||
|
missedPings = 0 |
||||||
|
pingTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in |
||||||
|
Task { @MainActor [weak self] in |
||||||
|
guard let self else { return } |
||||||
|
self.missedPings += 1 |
||||||
|
if self.missedPings >= 3 { |
||||||
|
self.logger.warning("Keep-alive timeout — \(self.missedPings) consecutive pings unanswered") |
||||||
|
self.pingTimer?.invalidate() |
||||||
|
self.pingTimer = nil |
||||||
|
self.commandTransport?.close() |
||||||
|
self.commandTransport = nil |
||||||
|
self.transition(to: .connectionLost("Host not responding")) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
transition(to: .connected(hostName)) |
||||||
|
logger.info("Command channel established with \(hostName)") |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Event Handling |
||||||
|
|
||||||
|
/// Parse an incoming NDJSON line as a `HostEvent` and dispatch to the appropriate callback. |
||||||
|
private func handleEventLine(_ line: String) { |
||||||
|
guard let data = line.data(using: .utf8) else { return } |
||||||
|
let decoder = JSONDecoder() |
||||||
|
|
||||||
|
do { |
||||||
|
let event = try decoder.decode(HostEvent.self, from: data) |
||||||
|
switch event { |
||||||
|
case .playbackState(let payload): |
||||||
|
missedPings = 0 |
||||||
|
onPlaybackState?(payload) |
||||||
|
case .dbReady: |
||||||
|
onDBReady?() |
||||||
|
case .error(let message): |
||||||
|
logger.error("Host error: \(message)") |
||||||
|
} |
||||||
|
} catch { |
||||||
|
logger.error("Failed to decode host event: \(error.localizedDescription)") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - State Machine |
||||||
|
|
||||||
|
/// Transition to a new connection state, validating via `canTransition(to:)`. |
||||||
|
private func transition(to newState: ConnectionState) { |
||||||
|
let oldState = connectionState |
||||||
|
guard oldState != newState else { return } |
||||||
|
|
||||||
|
guard oldState.canTransition(to: newState) else { |
||||||
|
logger.warning("Invalid transition: \(String(describing: oldState)) → \(String(describing: newState))") |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
logger.info("State: \(String(describing: oldState)) → \(String(describing: newState))") |
||||||
|
connectionState = newState |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Helpers |
||||||
|
|
||||||
|
/// Delete the local remote database file if it exists. |
||||||
|
private func deleteRemoteDB() { |
||||||
|
let path = Self.remoteDBPath |
||||||
|
if FileManager.default.fileExists(atPath: path) { |
||||||
|
do { |
||||||
|
try FileManager.default.removeItem(atPath: path) |
||||||
|
logger.info("Deleted remote DB at \(path)") |
||||||
|
} catch { |
||||||
|
logger.error("Failed to delete remote DB: \(error.localizedDescription)") |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,6 @@ |
|||||||
|
import os |
||||||
|
|
||||||
|
enum RemoteLogger { |
||||||
|
static let host = Logger(subsystem: "com.music.remote", category: "host") |
||||||
|
static let client = Logger(subsystem: "com.music.remote", category: "client") |
||||||
|
} |
||||||
@ -0,0 +1,172 @@ |
|||||||
|
import Foundation |
||||||
|
|
||||||
|
// MARK: - Protocol Version |
||||||
|
|
||||||
|
/// Current version of the remote control wire protocol. |
||||||
|
nonisolated let RemoteProtocolVersion: Int = 1 |
||||||
|
|
||||||
|
// MARK: - Supporting Types |
||||||
|
|
||||||
|
/// Snapshot of the host's playback state, sent to remote clients. |
||||||
|
nonisolated struct PlaybackStatePayload: Codable, Equatable, Sendable { |
||||||
|
var trackId: Int64? |
||||||
|
var isPlaying: Bool |
||||||
|
var currentTime: Double |
||||||
|
var duration: Double |
||||||
|
var volume: Float |
||||||
|
var isShuffled: Bool |
||||||
|
} |
||||||
|
|
||||||
|
/// Exchanged during connection setup to agree on protocol version. |
||||||
|
nonisolated struct HandshakeMessage: Codable, Equatable, Sendable { |
||||||
|
var protocolVersion: Int |
||||||
|
var appVersion: String |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - RemoteCommand |
||||||
|
|
||||||
|
/// Commands sent from a remote client to the host. |
||||||
|
/// Wire format: `{"type":"<case>","payload":{...}}` (payload omitted for cases with no associated values). |
||||||
|
nonisolated enum RemoteCommand: Equatable, Sendable { |
||||||
|
case play(trackId: Int64, queueIds: [Int64]) |
||||||
|
case pause |
||||||
|
case resume |
||||||
|
case next |
||||||
|
case previous |
||||||
|
case seek(position: Double) |
||||||
|
case setVolume(level: Float) |
||||||
|
case toggleShuffle |
||||||
|
case refreshDB |
||||||
|
} |
||||||
|
|
||||||
|
extension RemoteCommand: Codable { |
||||||
|
private enum TypeKey: String, Codable { |
||||||
|
case play, pause, resume, next, previous, seek, setVolume, toggleShuffle, refreshDB |
||||||
|
} |
||||||
|
|
||||||
|
private enum CodingKeys: String, CodingKey { |
||||||
|
case type, payload |
||||||
|
} |
||||||
|
|
||||||
|
// Payload structs for cases with associated values |
||||||
|
private struct PlayPayload: Codable { |
||||||
|
var trackId: Int64 |
||||||
|
var queueIds: [Int64] |
||||||
|
} |
||||||
|
|
||||||
|
private struct SeekPayload: Codable { |
||||||
|
var position: Double |
||||||
|
} |
||||||
|
|
||||||
|
private struct VolumePayload: Codable { |
||||||
|
var level: Float |
||||||
|
} |
||||||
|
|
||||||
|
func encode(to encoder: Encoder) throws { |
||||||
|
var container = encoder.container(keyedBy: CodingKeys.self) |
||||||
|
switch self { |
||||||
|
case .play(let trackId, let queueIds): |
||||||
|
try container.encode(TypeKey.play, forKey: .type) |
||||||
|
try container.encode(PlayPayload(trackId: trackId, queueIds: queueIds), forKey: .payload) |
||||||
|
case .pause: |
||||||
|
try container.encode(TypeKey.pause, forKey: .type) |
||||||
|
case .resume: |
||||||
|
try container.encode(TypeKey.resume, forKey: .type) |
||||||
|
case .next: |
||||||
|
try container.encode(TypeKey.next, forKey: .type) |
||||||
|
case .previous: |
||||||
|
try container.encode(TypeKey.previous, forKey: .type) |
||||||
|
case .seek(let position): |
||||||
|
try container.encode(TypeKey.seek, forKey: .type) |
||||||
|
try container.encode(SeekPayload(position: position), forKey: .payload) |
||||||
|
case .setVolume(let level): |
||||||
|
try container.encode(TypeKey.setVolume, forKey: .type) |
||||||
|
try container.encode(VolumePayload(level: level), forKey: .payload) |
||||||
|
case .toggleShuffle: |
||||||
|
try container.encode(TypeKey.toggleShuffle, forKey: .type) |
||||||
|
case .refreshDB: |
||||||
|
try container.encode(TypeKey.refreshDB, forKey: .type) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
init(from decoder: Decoder) throws { |
||||||
|
let container = try decoder.container(keyedBy: CodingKeys.self) |
||||||
|
let type = try container.decode(TypeKey.self, forKey: .type) |
||||||
|
switch type { |
||||||
|
case .play: |
||||||
|
let payload = try container.decode(PlayPayload.self, forKey: .payload) |
||||||
|
self = .play(trackId: payload.trackId, queueIds: payload.queueIds) |
||||||
|
case .pause: |
||||||
|
self = .pause |
||||||
|
case .resume: |
||||||
|
self = .resume |
||||||
|
case .next: |
||||||
|
self = .next |
||||||
|
case .previous: |
||||||
|
self = .previous |
||||||
|
case .seek: |
||||||
|
let payload = try container.decode(SeekPayload.self, forKey: .payload) |
||||||
|
self = .seek(position: payload.position) |
||||||
|
case .setVolume: |
||||||
|
let payload = try container.decode(VolumePayload.self, forKey: .payload) |
||||||
|
self = .setVolume(level: payload.level) |
||||||
|
case .toggleShuffle: |
||||||
|
self = .toggleShuffle |
||||||
|
case .refreshDB: |
||||||
|
self = .refreshDB |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - HostEvent |
||||||
|
|
||||||
|
/// Events sent from the host to remote clients. |
||||||
|
/// Wire format: `{"type":"<case>","payload":{...}}` (payload omitted for cases with no associated values). |
||||||
|
nonisolated enum HostEvent: Equatable, Sendable { |
||||||
|
case playbackState(PlaybackStatePayload) |
||||||
|
case dbReady |
||||||
|
case error(message: String) |
||||||
|
} |
||||||
|
|
||||||
|
extension HostEvent: Codable { |
||||||
|
private enum TypeKey: String, Codable { |
||||||
|
case playbackState, dbReady, error |
||||||
|
} |
||||||
|
|
||||||
|
private enum CodingKeys: String, CodingKey { |
||||||
|
case type, payload |
||||||
|
} |
||||||
|
|
||||||
|
private struct ErrorPayload: Codable { |
||||||
|
var message: String |
||||||
|
} |
||||||
|
|
||||||
|
func encode(to encoder: Encoder) throws { |
||||||
|
var container = encoder.container(keyedBy: CodingKeys.self) |
||||||
|
switch self { |
||||||
|
case .playbackState(let payload): |
||||||
|
try container.encode(TypeKey.playbackState, forKey: .type) |
||||||
|
try container.encode(payload, forKey: .payload) |
||||||
|
case .dbReady: |
||||||
|
try container.encode(TypeKey.dbReady, forKey: .type) |
||||||
|
case .error(let message): |
||||||
|
try container.encode(TypeKey.error, forKey: .type) |
||||||
|
try container.encode(ErrorPayload(message: message), forKey: .payload) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
init(from decoder: Decoder) throws { |
||||||
|
let container = try decoder.container(keyedBy: CodingKeys.self) |
||||||
|
let type = try container.decode(TypeKey.self, forKey: .type) |
||||||
|
switch type { |
||||||
|
case .playbackState: |
||||||
|
let payload = try container.decode(PlaybackStatePayload.self, forKey: .payload) |
||||||
|
self = .playbackState(payload) |
||||||
|
case .dbReady: |
||||||
|
self = .dbReady |
||||||
|
case .error: |
||||||
|
let payload = try container.decode(ErrorPayload.self, forKey: .payload) |
||||||
|
self = .error(message: payload.message) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,65 @@ |
|||||||
|
import SwiftUI |
||||||
|
import Network |
||||||
|
|
||||||
|
struct ConnectionSheet: View { |
||||||
|
var remoteClient: RemoteClient |
||||||
|
@Binding var isPresented: Bool |
||||||
|
|
||||||
|
var body: some View { |
||||||
|
VStack(spacing: 16) { |
||||||
|
Text("Connect to Host") |
||||||
|
.font(.headline) |
||||||
|
|
||||||
|
if let message = remoteClient.connectionState.userMessage { |
||||||
|
HStack(spacing: 8) { |
||||||
|
if !remoteClient.connectionState.isConnected && |
||||||
|
remoteClient.connectionState != .disconnected { |
||||||
|
ProgressView().controlSize(.small) |
||||||
|
} |
||||||
|
Text(message) |
||||||
|
.font(.subheadline) |
||||||
|
.foregroundStyle(.secondary) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if case .connectionLost(let reason) = remoteClient.connectionState { |
||||||
|
VStack(spacing: 8) { |
||||||
|
Text(reason).font(.caption).foregroundStyle(.red) |
||||||
|
Button("Retry") { remoteClient.startDiscovery() } |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if remoteClient.discoveredHosts.isEmpty && remoteClient.connectionState == .discovering { |
||||||
|
VStack(spacing: 8) { |
||||||
|
ProgressView() |
||||||
|
Text("Looking for hosts on your network...") |
||||||
|
.font(.caption).foregroundStyle(.secondary) |
||||||
|
} |
||||||
|
.frame(height: 100) |
||||||
|
} else { |
||||||
|
List(remoteClient.discoveredHosts, id: \.name) { host in |
||||||
|
HStack { |
||||||
|
Image(systemName: "desktopcomputer").foregroundStyle(.secondary) |
||||||
|
Text(host.name) |
||||||
|
Spacer() |
||||||
|
Button("Connect") { remoteClient.connect(to: host) } |
||||||
|
.buttonStyle(.borderedProminent).controlSize(.small) |
||||||
|
} |
||||||
|
.padding(.vertical, 4) |
||||||
|
} |
||||||
|
.frame(minHeight: 100, maxHeight: 200) |
||||||
|
} |
||||||
|
|
||||||
|
Button("Cancel") { |
||||||
|
remoteClient.stopDiscovery() |
||||||
|
isPresented = false |
||||||
|
} |
||||||
|
.keyboardShortcut(.cancelAction) |
||||||
|
} |
||||||
|
.padding(20) |
||||||
|
.frame(width: 380) |
||||||
|
.onChange(of: remoteClient.connectionState) { _, newState in |
||||||
|
if case .connected = newState { isPresented = false } |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,44 @@ |
|||||||
|
import Testing |
||||||
|
import Foundation |
||||||
|
@testable import Music |
||||||
|
|
||||||
|
struct ConnectionStateTests { |
||||||
|
|
||||||
|
// Verifies that each valid forward transition is allowed. |
||||||
|
@Test func validTransitionsSucceed() { |
||||||
|
#expect(ConnectionState.disconnected.canTransition(to: .discovering) == true) |
||||||
|
#expect(ConnectionState.discovering.canTransition(to: .foundHost("Mac Mini")) == true) |
||||||
|
#expect(ConnectionState.foundHost("Mac Mini").canTransition(to: .downloadingDB) == true) |
||||||
|
#expect(ConnectionState.downloadingDB.canTransition(to: .connectingCommandChannel) == true) |
||||||
|
#expect(ConnectionState.connectingCommandChannel.canTransition(to: .connected("Mac Mini")) == true) |
||||||
|
#expect(ConnectionState.connected("Mac Mini").canTransition(to: .connectionLost("Network changed")) == true) |
||||||
|
#expect(ConnectionState.connectionLost("Network changed").canTransition(to: .discovering) == true) |
||||||
|
} |
||||||
|
|
||||||
|
// Verifies that skipping states is rejected. |
||||||
|
@Test func invalidTransitionsRejected() { |
||||||
|
#expect(ConnectionState.disconnected.canTransition(to: .connected("Mac Mini")) == false) |
||||||
|
#expect(ConnectionState.discovering.canTransition(to: .connected("Mac Mini")) == false) |
||||||
|
#expect(ConnectionState.connected("Mac Mini").canTransition(to: .discovering) == false) |
||||||
|
} |
||||||
|
|
||||||
|
// Any state can transition to disconnected (user can always disconnect). |
||||||
|
@Test func anyStateCanDisconnect() { |
||||||
|
#expect(ConnectionState.discovering.canTransition(to: .disconnected) == true) |
||||||
|
#expect(ConnectionState.foundHost("X").canTransition(to: .disconnected) == true) |
||||||
|
#expect(ConnectionState.downloadingDB.canTransition(to: .disconnected) == true) |
||||||
|
#expect(ConnectionState.connectingCommandChannel.canTransition(to: .disconnected) == true) |
||||||
|
#expect(ConnectionState.connected("X").canTransition(to: .disconnected) == true) |
||||||
|
} |
||||||
|
|
||||||
|
// Verifies the human-readable status message for each state. |
||||||
|
@Test func userVisibleDescriptions() { |
||||||
|
#expect(ConnectionState.disconnected.userMessage == nil) |
||||||
|
#expect(ConnectionState.discovering.userMessage == "Searching for hosts...") |
||||||
|
#expect(ConnectionState.foundHost("Mac Mini").userMessage == "Found Mac Mini") |
||||||
|
#expect(ConnectionState.downloadingDB.userMessage == "Downloading library...") |
||||||
|
#expect(ConnectionState.connectingCommandChannel.userMessage == "Connecting...") |
||||||
|
#expect(ConnectionState.connected("Mac Mini").userMessage == "Connected to Mac Mini") |
||||||
|
#expect(ConnectionState.connectionLost("Network changed").userMessage == "Connection lost — Network changed") |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,164 @@ |
|||||||
|
import Testing |
||||||
|
import Foundation |
||||||
|
import Network |
||||||
|
@testable import Music |
||||||
|
|
||||||
|
@MainActor |
||||||
|
struct HostServerIntegrationTests { |
||||||
|
|
||||||
|
// Starts a HostServer, connects via TCP, sends GET /db, |
||||||
|
// verifies the response contains valid SQLite data. |
||||||
|
@Test(.timeLimit(.minutes(1))) |
||||||
|
func dbDownloadReturnsValidSQLite() async throws { |
||||||
|
// 1. Create a temp directory and a SQLite database with one track |
||||||
|
let tempDir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) |
||||||
|
try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true) |
||||||
|
let dbPath = tempDir.appendingPathComponent("db.sqlite").path |
||||||
|
let db = try DatabaseService(path: dbPath) |
||||||
|
var track = Track.fixture(fileURL: "/test.mp3") |
||||||
|
try db.insert(&track) |
||||||
|
|
||||||
|
// 2. Start the HostServer (configured with db for WAL checkpoint) and wait for the listener to be ready |
||||||
|
let server = HostServer(dbPath: dbPath) |
||||||
|
server.configure(player: nil, db: db) |
||||||
|
try server.start() |
||||||
|
try await Task.sleep(for: .milliseconds(200)) |
||||||
|
let port = server.actualPort! |
||||||
|
|
||||||
|
// 3. Perform an HTTP GET /db request to download the database |
||||||
|
let responseData = try await httpGet(host: "127.0.0.1", port: port, path: "/db") |
||||||
|
|
||||||
|
// 4. Verify the response starts with the SQLite magic header |
||||||
|
let header = String(data: responseData.prefix(16), encoding: .utf8) ?? "" |
||||||
|
#expect(header.hasPrefix("SQLite format 3")) |
||||||
|
|
||||||
|
// 5. Write the downloaded data to disk and verify it contains the inserted track |
||||||
|
let downloadedPath = tempDir.appendingPathComponent("downloaded.sqlite").path |
||||||
|
try responseData.write(to: URL(fileURLWithPath: downloadedPath)) |
||||||
|
let downloadedDb = try DatabaseService(path: downloadedPath) |
||||||
|
#expect(try downloadedDb.trackCount() == 1) |
||||||
|
|
||||||
|
// 6. Clean up |
||||||
|
server.stop() |
||||||
|
try? FileManager.default.removeItem(at: tempDir) |
||||||
|
} |
||||||
|
|
||||||
|
// Connects to /cmd, sends a pause command, verifies a playbackState event comes back. |
||||||
|
@Test(.timeLimit(.minutes(1))) |
||||||
|
func commandChannelRoundTrip() async throws { |
||||||
|
// 1. Create a temp directory and an empty SQLite database |
||||||
|
let tempDir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) |
||||||
|
try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true) |
||||||
|
let dbPath = tempDir.appendingPathComponent("db.sqlite").path |
||||||
|
_ = try DatabaseService(path: dbPath) |
||||||
|
|
||||||
|
// 2. Set up the player and server with command dispatch configured |
||||||
|
let audio = AudioService() |
||||||
|
let player = PlayerViewModel(audio: audio, db: nil) |
||||||
|
let server = HostServer(dbPath: dbPath) |
||||||
|
server.configure(player: player, db: nil) |
||||||
|
try server.start() |
||||||
|
try await Task.sleep(for: .milliseconds(200)) |
||||||
|
let port = server.actualPort! |
||||||
|
|
||||||
|
// 3. Open a command channel connection via GET /cmd |
||||||
|
let connection = try await connectCommandChannel(host: "127.0.0.1", port: port) |
||||||
|
|
||||||
|
// 4. Send a pause command as NDJSON |
||||||
|
let pauseCmd = try JSONEncoder().encode(RemoteCommand.pause) |
||||||
|
var lineData = pauseCmd |
||||||
|
lineData.append(contentsOf: "\n".utf8) |
||||||
|
connection.send(content: lineData, completion: .contentProcessed { _ in }) |
||||||
|
|
||||||
|
// 5. Wait for and decode the playbackState response event |
||||||
|
let responseLine = try await receiveOneLine(on: connection) |
||||||
|
let event = try JSONDecoder().decode(HostEvent.self, from: Data(responseLine.utf8)) |
||||||
|
|
||||||
|
// 6. Verify it is a playbackState event with isPlaying == false |
||||||
|
if case .playbackState(let payload) = event { |
||||||
|
#expect(payload.isPlaying == false) |
||||||
|
} else { |
||||||
|
Issue.record("Expected playbackState, got \(event)") |
||||||
|
} |
||||||
|
|
||||||
|
// 7. Clean up |
||||||
|
connection.cancel() |
||||||
|
server.stop() |
||||||
|
try? FileManager.default.removeItem(at: tempDir) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Helpers |
||||||
|
|
||||||
|
/// Performs a simple HTTP GET using NWConnection and returns the response body. |
||||||
|
private func httpGet(host: String, port: UInt16, path: String) async throws -> Data { |
||||||
|
try await withCheckedThrowingContinuation { continuation in |
||||||
|
let connection = NWConnection( |
||||||
|
host: NWEndpoint.Host(host), |
||||||
|
port: NWEndpoint.Port(rawValue: port)!, |
||||||
|
using: .tcp |
||||||
|
) |
||||||
|
connection.stateUpdateHandler = { state in |
||||||
|
if case .ready = state { |
||||||
|
// Send the HTTP request |
||||||
|
let request = "GET \(path) HTTP/1.1\r\nHost: \(host)\r\nConnection: close\r\n\r\n" |
||||||
|
connection.send(content: Data(request.utf8), completion: .contentProcessed { _ in }) |
||||||
|
// Receive the full response (Connection: close ensures we get everything) |
||||||
|
connection.receiveMessage { data, _, _, error in |
||||||
|
if let error { |
||||||
|
continuation.resume(throwing: error) |
||||||
|
} else if let data, let range = data.range(of: Data("\r\n\r\n".utf8)) { |
||||||
|
// Strip HTTP headers, return just the body |
||||||
|
continuation.resume(returning: Data(data[range.upperBound...])) |
||||||
|
} else { |
||||||
|
continuation.resume(returning: data ?? Data()) |
||||||
|
} |
||||||
|
connection.cancel() |
||||||
|
} |
||||||
|
} else if case .failed(let error) = state { |
||||||
|
continuation.resume(throwing: error) |
||||||
|
} |
||||||
|
} |
||||||
|
connection.start(queue: .main) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Opens a TCP connection to the /cmd endpoint and waits for the HTTP response header. |
||||||
|
private func connectCommandChannel(host: String, port: UInt16) async throws -> NWConnection { |
||||||
|
try await withCheckedThrowingContinuation { continuation in |
||||||
|
let connection = NWConnection( |
||||||
|
host: NWEndpoint.Host(host), |
||||||
|
port: NWEndpoint.Port(rawValue: port)!, |
||||||
|
using: .tcp |
||||||
|
) |
||||||
|
connection.stateUpdateHandler = { state in |
||||||
|
if case .ready = state { |
||||||
|
// Send the HTTP upgrade request for the command channel |
||||||
|
let request = "GET /cmd HTTP/1.1\r\nHost: \(host)\r\nConnection: keep-alive\r\n\r\n" |
||||||
|
connection.send(content: Data(request.utf8), completion: .contentProcessed { _ in }) |
||||||
|
// Consume the HTTP 200 response header |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { _, _, _, _ in |
||||||
|
continuation.resume(returning: connection) |
||||||
|
} |
||||||
|
} else if case .failed(let error) = state { |
||||||
|
continuation.resume(throwing: error) |
||||||
|
} |
||||||
|
} |
||||||
|
connection.start(queue: .main) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// Reads one newline-delimited line from a connection. |
||||||
|
private func receiveOneLine(on connection: NWConnection) async throws -> String { |
||||||
|
try await withCheckedThrowingContinuation { continuation in |
||||||
|
connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, _, error in |
||||||
|
if let error { |
||||||
|
continuation.resume(throwing: error) |
||||||
|
} else { |
||||||
|
let text = data.flatMap { String(data: $0, encoding: .utf8) } ?? "" |
||||||
|
// Extract the first complete line from the received data |
||||||
|
continuation.resume(returning: text.split(separator: "\n").first.map(String.init) ?? text) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,32 @@ |
|||||||
|
import Testing |
||||||
|
import Foundation |
||||||
|
@testable import Music |
||||||
|
|
||||||
|
struct NDJSONTransportTests { |
||||||
|
|
||||||
|
// Verifies that feed() correctly splits newline-delimited input into individual lines. |
||||||
|
@Test func splitsLinesCorrectly() { |
||||||
|
var lines: [String] = [] |
||||||
|
let buffer = NDJSONLineBuffer { lines.append($0) } |
||||||
|
buffer.feed(Data("{\"type\":\"pause\"}\n{\"type\":\"resume\"}\n".utf8)) |
||||||
|
#expect(lines == ["{\"type\":\"pause\"}", "{\"type\":\"resume\"}"]) |
||||||
|
} |
||||||
|
|
||||||
|
// Verifies that a line split across two TCP reads is reassembled. |
||||||
|
@Test func handlesPartialLines() { |
||||||
|
var lines: [String] = [] |
||||||
|
let buffer = NDJSONLineBuffer { lines.append($0) } |
||||||
|
buffer.feed(Data("{\"type\":\"pa".utf8)) |
||||||
|
#expect(lines.isEmpty) |
||||||
|
buffer.feed(Data("use\"}\n".utf8)) |
||||||
|
#expect(lines == ["{\"type\":\"pause\"}"]) |
||||||
|
} |
||||||
|
|
||||||
|
// Verifies empty lines are ignored. |
||||||
|
@Test func ignoresEmptyLines() { |
||||||
|
var lines: [String] = [] |
||||||
|
let buffer = NDJSONLineBuffer { lines.append($0) } |
||||||
|
buffer.feed(Data("\n\n{\"type\":\"next\"}\n\n".utf8)) |
||||||
|
#expect(lines == ["{\"type\":\"next\"}"]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,132 @@ |
|||||||
|
import Foundation |
||||||
|
import Testing |
||||||
|
@testable import Music |
||||||
|
|
||||||
|
struct RemoteProtocolTests { |
||||||
|
private let encoder: JSONEncoder = { |
||||||
|
let e = JSONEncoder() |
||||||
|
e.outputFormatting = [.sortedKeys] |
||||||
|
return e |
||||||
|
}() |
||||||
|
private let decoder = JSONDecoder() |
||||||
|
|
||||||
|
// MARK: - Helpers |
||||||
|
|
||||||
|
/// Encode then decode a value, returning the decoded copy. |
||||||
|
private func roundTrip<T: Codable>(_ value: T) throws -> T { |
||||||
|
let data = try encoder.encode(value) |
||||||
|
return try decoder.decode(T.self, from: data) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - RemoteCommand round-trip tests |
||||||
|
// Each test encodes a RemoteCommand case to JSON and decodes it back, |
||||||
|
// verifying the decoded value equals the original. |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_play() throws { |
||||||
|
let cmd = RemoteCommand.play(trackId: 42, queueIds: [42, 43, 44, 45]) |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_pause() throws { |
||||||
|
let cmd = RemoteCommand.pause |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_resume() throws { |
||||||
|
let cmd = RemoteCommand.resume |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_next() throws { |
||||||
|
let cmd = RemoteCommand.next |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_previous() throws { |
||||||
|
let cmd = RemoteCommand.previous |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_seek() throws { |
||||||
|
let cmd = RemoteCommand.seek(position: 123.456) |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_setVolume() throws { |
||||||
|
let cmd = RemoteCommand.setVolume(level: 0.75) |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_toggleShuffle() throws { |
||||||
|
let cmd = RemoteCommand.toggleShuffle |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func remoteCommandRoundTrip_refreshDB() throws { |
||||||
|
let cmd = RemoteCommand.refreshDB |
||||||
|
#expect(try roundTrip(cmd) == cmd) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - HostEvent round-trip tests |
||||||
|
// Each test encodes a HostEvent case to JSON and decodes it back, |
||||||
|
// verifying the decoded value equals the original. |
||||||
|
|
||||||
|
@Test func hostEventRoundTrip_playbackState() throws { |
||||||
|
let payload = PlaybackStatePayload( |
||||||
|
trackId: 7, |
||||||
|
isPlaying: true, |
||||||
|
currentTime: 42.5, |
||||||
|
duration: 210.0, |
||||||
|
volume: 0.8, |
||||||
|
isShuffled: false |
||||||
|
) |
||||||
|
let event = HostEvent.playbackState(payload) |
||||||
|
#expect(try roundTrip(event) == event) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func hostEventRoundTrip_dbReady() throws { |
||||||
|
let event = HostEvent.dbReady |
||||||
|
#expect(try roundTrip(event) == event) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func hostEventRoundTrip_error() throws { |
||||||
|
let event = HostEvent.error(message: "Something went wrong") |
||||||
|
#expect(try roundTrip(event) == event) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - HandshakeMessage round-trip test |
||||||
|
// Verifies HandshakeMessage survives JSON encoding and decoding. |
||||||
|
|
||||||
|
@Test func handshakeMessageRoundTrip() throws { |
||||||
|
let msg = HandshakeMessage(protocolVersion: RemoteProtocolVersion, appVersion: "1.2.3") |
||||||
|
#expect(try roundTrip(msg) == msg) |
||||||
|
} |
||||||
|
|
||||||
|
// MARK: - Wire format decode tests |
||||||
|
// Verify that hand-crafted JSON strings matching the expected wire format |
||||||
|
// decode correctly, ensuring the Codable implementation matches the spec. |
||||||
|
|
||||||
|
@Test func wireFormatDecode_playCommand() throws { |
||||||
|
let json = """ |
||||||
|
{"type":"play","payload":{"trackId":42,"queueIds":[42,43,44,45]}} |
||||||
|
""" |
||||||
|
let decoded = try decoder.decode(RemoteCommand.self, from: Data(json.utf8)) |
||||||
|
#expect(decoded == .play(trackId: 42, queueIds: [42, 43, 44, 45])) |
||||||
|
} |
||||||
|
|
||||||
|
@Test func wireFormatDecode_playbackStateEvent() throws { |
||||||
|
let json = """ |
||||||
|
{"type":"playbackState","payload":{"trackId":7,"isPlaying":true,"currentTime":42.5,"duration":210.0,"volume":0.8,"isShuffled":false}} |
||||||
|
""" |
||||||
|
let decoded = try decoder.decode(HostEvent.self, from: Data(json.utf8)) |
||||||
|
let expected = HostEvent.playbackState(PlaybackStatePayload( |
||||||
|
trackId: 7, |
||||||
|
isPlaying: true, |
||||||
|
currentTime: 42.5, |
||||||
|
duration: 210.0, |
||||||
|
volume: 0.8, |
||||||
|
isShuffled: false |
||||||
|
)) |
||||||
|
#expect(decoded == expected) |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue