diff --git a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift index 522a6c2..49cb91b 100644 --- a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift +++ b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift @@ -13,6 +13,12 @@ enum RemoteAudioSourceError: Error { } public class RemoteAudioSource: AudioStreamSource { + /// Time without any received data after which a request fails and is retried. + /// Short enough to detect a dead connection (e.g. after a cell handover) while the buffer still plays. + static let requestTimeoutInterval: TimeInterval = 15 + /// A stream that has not received data for this long is reopened when the network path changes. + static let stallIntervalForPathChange: TimeInterval = 2 + public weak var delegate: AudioStreamSourceDelegate? public var position: Int { @@ -57,6 +63,22 @@ public class RemoteAudioSource: AudioStreamSource { var waitingForNetwork = false let retrierTimeout: Retrier + private let receiveStateLock = UnfairLock() + /// The time data was last received; `nil` while no stream request is open + private var lastDataReceivedAt: DispatchTime? + + /// Length of the stream start kept to check that a reopened stream delivers the same content + static let streamHeadLength = 4096 + /// The first bytes of the stream, to verify a resume without range support + private var streamHead = Data() + /// Progress of dropping the already read bytes after reopening a stream without range support + private var resumeSkip: ResumeSkip? + + private struct ResumeSkip { + let bytesToSkip: Int + var received = 0 + } + init(networking: NetworkingClient, metadataStreamSource: MetadataStreamSource, icycastHeadersProcessor: IcycastHeadersProcessor, @@ -138,6 +160,7 @@ public class RemoteAudioSource: AudioStreamSource { } public func close() { + setLastDataReceived(nil) retrierTimeout.cancel() streamOperationQueue.isSuspended = false streamOperationQueue.cancelAllOperations() @@ -149,12 +172,18 @@ public class RemoteAudioSource: AudioStreamSource { } public func seek(at offset: Int) { + reopen(at: offset, skipping: 0) + } + + /// - Parameter bytesToSkip: Bytes at the start of the stream the player has already read + private func reopen(at offset: Int, skipping bytesToSkip: Int) { close() - relativePosition = 0 + relativePosition = bytesToSkip seekOffset = offset + resumeSkip = bytesToSkip > 0 ? ResumeSkip(bytesToSkip: bytesToSkip) : nil - if !supportsSeek, offset != relativePosition { + if !supportsSeek, offset != 0 { return } @@ -182,12 +211,30 @@ public class RemoteAudioSource: AudioStreamSource { guard let self = self else { return } guard connection.isConnected else { return } if self.waitingForNetwork { - self.seek(at: self.supportsSeek ? self.position : 0) + self.reopenAtCurrentPosition() self.waitingForNetwork = false + } else if self.isStreamStalled { + // The path changed (new cell, interface or address) while no data arrived: + // the open connection is most likely dead, so reopen it instead of waiting for the timeout + self.reopenAtCurrentPosition() } } } + private var isStreamStalled: Bool { + receiveStateLock.withLock { () -> Bool in + guard let lastDataReceivedAt else { return false } + let elapsed = DispatchTime.now().uptimeNanoseconds - lastDataReceivedAt.uptimeNanoseconds + return Double(elapsed) / Double(NSEC_PER_SEC) >= Self.stallIntervalForPathChange + } + } + + private func setLastDataReceived(_ time: DispatchTime?) { + receiveStateLock.withLock { + lastDataReceivedAt = time + } + } + private func performOpen(seek seekOffset: Int) { if seekOffset == 0 { initialRequest { [weak self] in @@ -210,6 +257,7 @@ public class RemoteAudioSource: AudioStreamSource { private func doPerfomOpen(seek seekOffset: Int) { let urlRequest = buildUrlRequest(with: url, seekIfNeeded: seekOffset) + setLastDataReceived(.now()) streamRequest = networkingClient.stream(request: urlRequest) .responseStream { [weak self] event in guard let self = self else { return } @@ -229,6 +277,11 @@ public class RemoteAudioSource: AudioStreamSource { self?.parseResponseHeader(response: urlResponse) task.cancel() completion() + case let .stream(.failure(error)): + // No response (e.g. a timeout without network): retry, otherwise the stream never opens. + // The cancellation above after a response also ends up here and is ignored. + guard (error as? URLError)?.code != .cancelled else { return } + self?.handleFailedStreamEvent(error: error) default: break } @@ -258,6 +311,12 @@ public class RemoteAudioSource: AudioStreamSource { // MARK: - Network Handle Methods private func handleResponse(event: NetworkDataStream.ResponseEvent) { + switch event { + case .response, .stream(.success): + setLastDataReceived(.now()) + case .stream(.failure), .complete: + setLastDataReceived(nil) + } switch event { case let .response(urlResponse): parseResponseHeader(response: urlResponse) @@ -299,11 +358,42 @@ public class RemoteAudioSource: AudioStreamSource { self.relativePosition += audioCount return } - let audioCount = self.processAudio(data: audioData) + guard let unreadData = self.dropAlreadyReadBytes(of: audioData) else { return } + self.recordStreamHead(unreadData) + let audioCount = self.processAudio(data: unreadData) self.relativePosition += audioCount } } + /// While resuming a stream without range support, drops the bytes the player has already read, + /// as long as the reopened stream starts with the same content. + /// - Returns: The data to process, or `nil` if the whole chunk was dropped + private func dropAlreadyReadBytes(of data: Data) -> Data? { + guard var skip = resumeSkip else { return data } + let compareEnd = min(streamHead.count, skip.bytesToSkip) + if skip.received < compareEnd { + let count = min(compareEnd - skip.received, data.count) + let expected = streamHead.subdata(in: skip.received ..< skip.received + count) + if Data(data.prefix(count)) != expected { + // Different content (e.g. a live stream): play the new stream from its start + resumeSkip = nil + relativePosition = 0 + streamHead = Data() + return data + } + } + let dropCount = min(skip.bytesToSkip - skip.received, data.count) + skip.received += dropCount + resumeSkip = skip.received < skip.bytesToSkip ? skip : nil + return dropCount < data.count ? Data(data.dropFirst(dropCount)) : nil + } + + private func recordStreamHead(_ data: Data) { + guard resumeSkip == nil, seekOffset == 0, streamHead.count == relativePosition, + streamHead.count < Self.streamHeadLength else { return } + streamHead.append(data.prefix(Self.streamHeadLength - streamHead.count)) + } + private func handleFailedStreamEvent(error _: Error) { if !netStatusService.isConnected { waitingForNetwork = true @@ -369,7 +459,7 @@ public class RemoteAudioSource: AudioStreamSource { var urlRequest = URLRequest(url: url) urlRequest.networkServiceType = .avStreaming urlRequest.cachePolicy = .reloadIgnoringLocalCacheData - urlRequest.timeoutInterval = 60 + urlRequest.timeoutInterval = Self.requestTimeoutInterval urlRequest.httpMethod = httpMethod urlRequest.httpBody = httpBody @@ -390,7 +480,7 @@ public class RemoteAudioSource: AudioStreamSource { var urlRequest = URLRequest(url: url) urlRequest.networkServiceType = .avStreaming urlRequest.cachePolicy = .reloadIgnoringLocalCacheData - urlRequest.timeoutInterval = 60 + urlRequest.timeoutInterval = Self.requestTimeoutInterval urlRequest.httpMethod = httpMethod urlRequest.httpBody = httpBody @@ -407,10 +497,30 @@ public class RemoteAudioSource: AudioStreamSource { private func retryOnError() { retrierTimeout.retry { [weak self] in guard let self = self else { return } - self.seek(at: self.supportsSeek ? self.position : 0) + self.reopenAtCurrentPosition() } } + /// Reopens the stream after a network failure or stall, continuing where the player stopped reading + private func reopenAtCurrentPosition() { + if supportsSeek { + seek(at: position) + } else if canResumeBySkipping { + // Without range support the stream starts over: drop the bytes already read + reopen(at: 0, skipping: position) + } else { + seek(at: 0) + } + } + + private var canResumeBySkipping: Bool { + position > 0 + && !metadataStreamProcessor.canProcessMetadata + && !shouldTryParsingIcycastHeaders + && !mp4Restructure.dataOptimized + && streamHead.count >= min(position, Self.streamHeadLength) + } + // MARK: - Network Stream Operation Queue /// Schedules the given block on the stream operation queue diff --git a/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift b/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift new file mode 100644 index 0000000..2de12fa --- /dev/null +++ b/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift @@ -0,0 +1,156 @@ +import Network +import XCTest +@testable import AudioStreaming + +/// Resuming a stream from a server without range support after the connection broke +final class RemoteAudioSourceResumeTests: XCTestCase { + private var server: NoRangeHTTPServer! + private var networking: NetworkingClient! + + override func tearDown() { + server?.stop() + server = nil + networking = nil + super.tearDown() + } + + func testResumeDropsAlreadyReadBytesOfSameContent() throws { + let payload = Self.randomData(count: 100_000) + server = try NoRangeHTTPServer { _ in payload } + server.cutFirstStreamAfter = 40000 + + let received = try readStream() + + XCTAssertEqual(server.streamRequestCount, 2) + XCTAssertEqual(received.count, payload.count) + XCTAssertEqual(received, payload) + } + + func testResumePlaysDifferentContentFromItsStart() throws { + let first = Self.randomData(count: 100_000) + let second = Self.randomData(count: 60000) + server = try NoRangeHTTPServer { index in index == 0 ? first : second } + server.cutFirstStreamAfter = 40000 + + let received = try readStream() + + XCTAssertEqual(server.streamRequestCount, 2) + XCTAssertEqual(received, first.prefix(40000) + second) + } + + // MARK: - Helpers + + private func readStream() throws -> Data { + try server.start() + networking = NetworkingClient() + let queue = DispatchQueue(label: "remote.audio.source.test") + let url = URL(string: "http://127.0.0.1:\(server.port)/song.mp3")! + let source = RemoteAudioSource(networking: networking, + metadataStreamSource: MetadataStreamProcessor(parser: MetadataParser().eraseToAnyParser()), + icycastHeadersProcessor: IcycastHeadersProcessor(), + netStatusProvider: ConnectedNetStatusProvider(), + retrier: Retrier(interval: .milliseconds(100), maxInterval: 1, underlyingQueue: nil), + url: url, + httpMethod: nil, + httpBody: nil, + underlyingQueue: queue, + httpHeaders: [:]) + let delegate = CollectingSourceDelegate() + delegate.finished = expectation(description: "end of file") + source.delegate = delegate + queue.async { source.seek(at: 0) } + wait(for: [delegate.finished!], timeout: 10) + source.close() + return delegate.data + } + + private static func randomData(count: Int) -> Data { + Data((0 ..< count).map { _ in UInt8.random(in: 0 ... 255) }) + } +} + +private final class ConnectedNetStatusProvider: NetStatusProvider { + var isConnected: Bool { true } + var connectionType: NetConnectionType { .wifi(connected: true) } + func start(connectionChange _: @escaping (NetConnectionType) -> Void) {} + func stop() {} +} + +private final class CollectingSourceDelegate: AudioStreamSourceDelegate { + private let lock = UnfairLock() + private var _data = Data() + var finished: XCTestExpectation? + + var data: Data { lock.withLock { _data } } + + func dataAvailable(source _: CoreAudioStreamSource, data: Data) { + lock.withLock { _data.append(data) } + } + + func errorOccurred(source _: CoreAudioStreamSource, error: Error) { + XCTFail("unexpected error: \(error)") + } + + func endOfFileOccurred(source _: CoreAudioStreamSource) { + finished?.fulfill() + } + + func metadataReceived(data _: [String: String]) {} +} + +/// Answers every request with 200 OK and the full body, ignoring `Range` headers. +/// The first request without a `Range` header (the audio stream) can be cut off after a number of bytes. +private final class NoRangeHTTPServer { + private let listener: NWListener + private let queue = DispatchQueue(label: "no.range.http.server") + private let bodyForStreamRequest: (Int) -> Data + private(set) var port: UInt16 = 0 + private(set) var streamRequestCount = 0 + var cutFirstStreamAfter: Int? + + init(bodyForStreamRequest: @escaping (Int) -> Data) throws { + self.bodyForStreamRequest = bodyForStreamRequest + let params = NWParameters.tcp + params.allowLocalEndpointReuse = true + listener = try NWListener(using: params, on: .any) + } + + func start() throws { + let ready = DispatchSemaphore(value: 0) + listener.stateUpdateHandler = { state in + if case .ready = state { ready.signal() } + } + listener.newConnectionHandler = { [weak self] connection in + self?.handle(connection) + } + listener.start(queue: queue) + _ = ready.wait(timeout: .now() + 5) + port = listener.port?.rawValue ?? 0 + } + + func stop() { + listener.cancel() + } + + private func handle(_ connection: NWConnection) { + connection.start(queue: queue) + connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] request, _, _, _ in + guard let self, let request else { return } + let isRangeRequest = String(decoding: request, as: UTF8.self).lowercased().contains("\r\nrange:") + var body = self.bodyForStreamRequest(self.streamRequestCount) + if !isRangeRequest { + self.streamRequestCount += 1 + } + let header = "HTTP/1.1 200 OK\r\n" + + "Content-Type: audio/mpeg\r\n" + + "Content-Length: \(body.count)\r\n" + + "Cache-Control: no-cache\r\n" + + "Connection: close\r\n\r\n" + if !isRangeRequest, self.streamRequestCount == 1, let cut = self.cutFirstStreamAfter { + body = body.prefix(cut) + } + connection.send(content: Data(header.utf8) + body, + completion: .contentProcessed { _ in connection.cancel() }) + } + } +}