react-native-audio-browser 0.2.0-next.81 → 0.2.0-next.83
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ios/Browser/BrowseGate.swift +14 -1
- package/ios/CarPlay/CarPlayNowPlayingManager.swift +23 -19
- package/ios/CarPlay/CarPlaySession+TabBar.swift +3 -5
- package/ios/CarPlay/MediaIntentHandler.swift +7 -2
- package/ios/CarPlay/MediaIntentPlayback.swift +23 -12
- package/ios/HybridAudioBrowser+Options.swift +1 -1
- package/ios/Model/NitroTypeStubs.swift +25 -0
- package/ios/Player/ErrorStatus.swift +4 -0
- package/ios/Player/PlaybackStateMachine.swift +4 -3
- package/ios/Player/Player.swift +53 -26
- package/ios/Player/RetryLoop.swift +198 -201
- package/ios/Tests/BrowseGateTests.swift +50 -0
- package/ios/Tests/ConnectivityTests.swift +13 -0
- package/ios/Tests/MediaIntentDeadlineTests.swift +75 -0
- package/ios/Tests/PlaybackStateMachineTests.swift +6 -6
- package/ios/Tests/PlayerPolicyTests.swift +273 -51
- package/ios/Tests/PlayerTests.swift +43 -85
- package/ios/Tests/RetryLoopTests.swift +299 -120
- package/ios/Tests/SupersedingTaskTests.swift +148 -0
- package/ios/Tests/Support/TestTypes.swift +99 -8
- package/ios/Util/Connectivity.swift +12 -0
- package/ios/Util/Deadline.swift +38 -0
- package/ios/Util/NetworkMonitor.swift +2 -2
- package/ios/Util/SupersedingTask.swift +45 -0
- package/package.json +1 -1
|
@@ -8,7 +8,7 @@ private func makeLoading(
|
|
|
8
8
|
live: Bool = false,
|
|
9
9
|
) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
|
|
10
10
|
let engine = MockPlayerEngine()
|
|
11
|
-
let player = makePlayer(engine: engine
|
|
11
|
+
let player = makePlayer(engine: engine)
|
|
12
12
|
let callbacks = MockPlayerCallbacks()
|
|
13
13
|
player.callbacks = callbacks
|
|
14
14
|
try player.setQueue([Track(id: "t1", src: src, title: "T", live: live)])
|
|
@@ -31,7 +31,7 @@ private func makePlaying(live: Bool = false) throws -> (Player, MockPlayerEngine
|
|
|
31
31
|
@MainActor
|
|
32
32
|
private func makeStalling(givesUp: Bool = false) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
|
|
33
33
|
let engine = MockPlayerEngine()
|
|
34
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(givesUp: givesUp)
|
|
34
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(givesUp: givesUp))
|
|
35
35
|
player.retry.stallTimeout = .milliseconds(10)
|
|
36
36
|
let callbacks = MockPlayerCallbacks()
|
|
37
37
|
player.callbacks = callbacks
|
|
@@ -45,6 +45,40 @@ private func makeStalling(givesUp: Bool = false) throws -> (Player, MockPlayerEn
|
|
|
45
45
|
return (player, engine, callbacks)
|
|
46
46
|
}
|
|
47
47
|
|
|
48
|
+
/// A live stream that loaded and waits to play, its retry loop on a virtual clock.
|
|
49
|
+
@MainActor
|
|
50
|
+
private func makeVirtual(online: Bool = true) throws -> (Player, MockPlayerEngine, MockPlayerCallbacks, VirtualClock) {
|
|
51
|
+
let clock = VirtualClock()
|
|
52
|
+
let retry = RetryLoop(online: online, clock: clock)
|
|
53
|
+
retry.updatePolicy(from: .first(true))
|
|
54
|
+
let engine = MockPlayerEngine()
|
|
55
|
+
let player = makePlayer(engine: engine, retry: retry)
|
|
56
|
+
let callbacks = MockPlayerCallbacks()
|
|
57
|
+
player.callbacks = callbacks
|
|
58
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T", live: true)], playWhenReady: true)
|
|
59
|
+
engine.hasItem = true
|
|
60
|
+
engine.hasLoadedAsset = true
|
|
61
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
62
|
+
return (player, engine, callbacks, clock)
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
/// A live stream connecting, its retry loop on a virtual clock; the engine reports `previousBuffered`
|
|
66
|
+
/// from the item the connect replaces until the test prepares one.
|
|
67
|
+
@MainActor
|
|
68
|
+
private func makeConnecting(
|
|
69
|
+
playWhenReady: Bool = true,
|
|
70
|
+
previousBuffered: Double = 0,
|
|
71
|
+
) throws -> (Player, MockPlayerEngine, VirtualClock) {
|
|
72
|
+
let clock = VirtualClock()
|
|
73
|
+
let retry = RetryLoop(clock: clock)
|
|
74
|
+
retry.updatePolicy(from: .first(true))
|
|
75
|
+
let engine = MockPlayerEngine()
|
|
76
|
+
engine.bufferedPosition = previousBuffered
|
|
77
|
+
let player = makePlayer(engine: engine, retry: retry)
|
|
78
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T", live: true)], playWhenReady: playWhenReady)
|
|
79
|
+
return (player, engine, clock)
|
|
80
|
+
}
|
|
81
|
+
|
|
48
82
|
@Suite("Player - seeking")
|
|
49
83
|
@MainActor
|
|
50
84
|
struct PlayerSeekingTests {
|
|
@@ -95,7 +129,7 @@ struct PlayerSeekingTests {
|
|
|
95
129
|
|
|
96
130
|
@Test func aCompletionFromBeforeAReloadIsDropped() throws {
|
|
97
131
|
let engine = MockPlayerEngine()
|
|
98
|
-
let player = makePlayer(engine: engine
|
|
132
|
+
let player = makePlayer(engine: engine)
|
|
99
133
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
100
134
|
engine.seekResult = nil
|
|
101
135
|
engine.hasItem = true
|
|
@@ -114,7 +148,7 @@ struct PlayerSeekingTests {
|
|
|
114
148
|
|
|
115
149
|
@Test func aStartSeekCutShortWaitsForTheNextItem() throws {
|
|
116
150
|
let engine = MockPlayerEngine()
|
|
117
|
-
let player = makePlayer(engine: engine
|
|
151
|
+
let player = makePlayer(engine: engine)
|
|
118
152
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
119
153
|
engine.seekResult = nil
|
|
120
154
|
engine.hasItem = true
|
|
@@ -130,7 +164,7 @@ struct PlayerSeekingTests {
|
|
|
130
164
|
/// A media-load retry passes no position, so the start in flight is what it resumes from.
|
|
131
165
|
@Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
|
|
132
166
|
let engine = MockPlayerEngine()
|
|
133
|
-
let player = makePlayer(engine: engine
|
|
167
|
+
let player = makePlayer(engine: engine)
|
|
134
168
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
135
169
|
engine.seekResult = nil
|
|
136
170
|
engine.hasItem = true
|
|
@@ -146,7 +180,7 @@ struct PlayerSeekingTests {
|
|
|
146
180
|
|
|
147
181
|
@Test func aMediaServicesResetDuringTheLoadKeepsTheStart() throws {
|
|
148
182
|
let engine = MockPlayerEngine()
|
|
149
|
-
let player = makePlayer(engine: engine
|
|
183
|
+
let player = makePlayer(engine: engine)
|
|
150
184
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
151
185
|
|
|
152
186
|
player.mediaServicesWereReset()
|
|
@@ -158,7 +192,7 @@ struct PlayerSeekingTests {
|
|
|
158
192
|
|
|
159
193
|
@Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
|
|
160
194
|
let engine = MockPlayerEngine()
|
|
161
|
-
let player = makePlayer(engine: engine
|
|
195
|
+
let player = makePlayer(engine: engine)
|
|
162
196
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
163
197
|
engine.seekResult = nil
|
|
164
198
|
engine.hasItem = true
|
|
@@ -174,7 +208,7 @@ struct PlayerSeekingTests {
|
|
|
174
208
|
|
|
175
209
|
@Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
|
|
176
210
|
let engine = MockPlayerEngine()
|
|
177
|
-
let player = makePlayer(engine: engine
|
|
211
|
+
let player = makePlayer(engine: engine)
|
|
178
212
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
|
|
179
213
|
engine.seekResult = nil
|
|
180
214
|
engine.hasItem = true
|
|
@@ -220,7 +254,6 @@ struct PlayerEngineEventTests {
|
|
|
220
254
|
@Test func aFailedLoadPrimesNowPlayingOncePerLoad() throws {
|
|
221
255
|
let (player, engine, _) = try makeLoading()
|
|
222
256
|
player.setPlayWhenReady(true)
|
|
223
|
-
player.retry.shouldRetry = { true }
|
|
224
257
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
225
258
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
226
259
|
#expect(engine.primeCount == 1)
|
|
@@ -286,18 +319,15 @@ struct PlayerEngineEventTests {
|
|
|
286
319
|
#expect(player.state == .ended)
|
|
287
320
|
|
|
288
321
|
let (live, liveEngine, _) = try makePlaying(live: true)
|
|
289
|
-
live.retry.shouldRetry = { true }
|
|
290
322
|
liveEngine.emit(.playedToEnd)
|
|
291
323
|
await live.retry.pendingTask?.value
|
|
292
324
|
#expect(live.state == .loading)
|
|
293
325
|
#expect(liveEngine.resolveAndLoadCalls.count == 2)
|
|
294
|
-
#expect(live.retry.attempts == 1)
|
|
295
326
|
}
|
|
296
327
|
|
|
297
328
|
/// AVPlayer pauses an item at its end, so a seek within its window would leave it silent.
|
|
298
329
|
@Test func aLiveEndReconnectsEvenWithASeekableWindow() async throws {
|
|
299
330
|
let (player, engine, _) = try makePlaying(live: true)
|
|
300
|
-
player.retry.shouldRetry = { true }
|
|
301
331
|
engine.liveEdge = 120
|
|
302
332
|
engine.emit(.playedToEnd)
|
|
303
333
|
await player.retry.pendingTask?.value
|
|
@@ -310,34 +340,30 @@ struct PlayerEngineEventTests {
|
|
|
310
340
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
311
341
|
maxRetries: 3, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
312
342
|
)))
|
|
313
|
-
player.retry.shouldRetry = { true }
|
|
314
343
|
for _ in 0 ..< 20 where player.state != .error {
|
|
315
344
|
engine.emit(.playedToEnd)
|
|
316
345
|
await player.retry.pendingTask?.value
|
|
346
|
+
engine.hasLoadedAsset = true
|
|
317
347
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
318
348
|
}
|
|
319
|
-
|
|
349
|
+
// The first connection played, so its end starts the count: four that deliver nothing follow.
|
|
350
|
+
#expect(engine.resolveAndLoadCalls.count == 5)
|
|
320
351
|
#expect(player.state == .error)
|
|
321
352
|
#expect(player.errorStatus.error == .playbackStalled)
|
|
322
353
|
#expect(callbacks.errorEvents.count == 1)
|
|
323
354
|
}
|
|
324
355
|
|
|
325
|
-
///
|
|
326
|
-
@Test func
|
|
356
|
+
/// A connection that delivered audio starts `maxRetries`' count over (docs/adr/0014).
|
|
357
|
+
@Test func liveEndsBetweenAudioNeverSpendMaxRetries() async throws {
|
|
327
358
|
let (player, engine, callbacks) = try makePlaying(live: true)
|
|
328
359
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
329
360
|
maxRetries: 1, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
330
361
|
)))
|
|
331
|
-
player.retry.shouldRetry = { true }
|
|
332
|
-
player.retry.healthyPlaybackDuration = .milliseconds(10)
|
|
333
362
|
for _ in 0 ..< 5 {
|
|
334
363
|
engine.emit(.playedToEnd)
|
|
335
364
|
await player.retry.pendingTask?.value
|
|
336
|
-
#expect(player.retry.attempts == 1)
|
|
337
365
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
338
366
|
player.transition(.avPlayerPlaying)
|
|
339
|
-
await player.retry.healthyPlaybackTask?.value
|
|
340
|
-
#expect(player.retry.attempts == 0)
|
|
341
367
|
}
|
|
342
368
|
#expect(engine.resolveAndLoadCalls.count == 6)
|
|
343
369
|
#expect(player.state == .playing)
|
|
@@ -357,7 +383,6 @@ struct PlayerEngineEventTests {
|
|
|
357
383
|
/// The engine stops observing an item on a reload; a played-to-end it delivered late is stale.
|
|
358
384
|
@Test func aPlayedToEndDuringALoadIsIgnored() throws {
|
|
359
385
|
let (player, engine, _) = try makePlaying(live: true)
|
|
360
|
-
player.retry.shouldRetry = { true }
|
|
361
386
|
player.reloadResolving(startFromCurrentTime: false)
|
|
362
387
|
#expect(player.state == .loading)
|
|
363
388
|
engine.emit(.playedToEnd)
|
|
@@ -416,7 +441,12 @@ struct PlayerRecoveringTests {
|
|
|
416
441
|
}
|
|
417
442
|
|
|
418
443
|
@Test func aStallWithNoFailureEndsInPlaybackStalledOnceTheBudgetIsSpent() async throws {
|
|
419
|
-
let (player,
|
|
444
|
+
let (player, engine, callbacks) = try makeStalling(givesUp: true)
|
|
445
|
+
await player.retry.stallTask?.value
|
|
446
|
+
await player.retry.pendingTask?.value
|
|
447
|
+
// The stalled connection had played, so even `maxRetries: 0` reconnects it once.
|
|
448
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
449
|
+
player.transition(.avPlayerWaiting)
|
|
420
450
|
await player.retry.stallTask?.value
|
|
421
451
|
await player.retry.pendingTask?.value
|
|
422
452
|
#expect(player.state == .error)
|
|
@@ -463,8 +493,91 @@ struct PlayerRecoveringTests {
|
|
|
463
493
|
|
|
464
494
|
@Test func aTrackChangeEndsTheStallWatch() throws {
|
|
465
495
|
let (player, _, _) = try makeStalling()
|
|
496
|
+
let stallWatch = player.retry.stallTask
|
|
466
497
|
try player.setQueue([Track(id: "t2", src: "https://example.com/b.mp3", title: "B")])
|
|
467
|
-
#expect(
|
|
498
|
+
#expect(stallWatch?.isCancelled == true)
|
|
499
|
+
}
|
|
500
|
+
|
|
501
|
+
@Test func aConnectThatSendsNothingIsReplacedAfterTheTimeout() async throws {
|
|
502
|
+
let (player, engine, clock) = try makeConnecting()
|
|
503
|
+
await clock.run(until: 30_999)
|
|
504
|
+
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
505
|
+
await clock.run(until: 31_000)
|
|
506
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
507
|
+
#expect(player.state == .loading)
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
/// The item it replaces had buffered further than the new one has yet.
|
|
511
|
+
@Test func aSlowConnectThatKeepsReceivingDataIsKept() async throws {
|
|
512
|
+
let (player, engine, clock) = try makeConnecting(previousBuffered: 50)
|
|
513
|
+
engine.hasItem = true
|
|
514
|
+
engine.bufferedPosition = 1
|
|
515
|
+
engine.emit(.itemPrepared(likelyToKeepUp: false))
|
|
516
|
+
for atMs in stride(from: 20_000, through: 100_000, by: 20_000) {
|
|
517
|
+
clock.at(atMs) { engine.bufferedPosition += 1 }
|
|
518
|
+
}
|
|
519
|
+
await clock.run(until: 100_000)
|
|
520
|
+
#expect(player.state == .loading)
|
|
521
|
+
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
/// A stall's reconnect: the stalled item stays in the engine, still buffering, while the new
|
|
525
|
+
/// connect sends nothing.
|
|
526
|
+
@Test func theItemAConnectReplacesBufferingOnIsNoProgress() async throws {
|
|
527
|
+
let (player, engine, _, clock) = try makeVirtual()
|
|
528
|
+
engine.bufferedPosition = 50
|
|
529
|
+
player.transition(.avPlayerPlaying)
|
|
530
|
+
await clock.run(until: 10_000)
|
|
531
|
+
player.transition(.avPlayerWaiting)
|
|
532
|
+
await clock.run(until: 40_000)
|
|
533
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
534
|
+
|
|
535
|
+
for atMs in stride(from: 45_000, through: 70_000, by: 5_000) {
|
|
536
|
+
clock.at(atMs) { engine.bufferedPosition += 1 }
|
|
537
|
+
}
|
|
538
|
+
await clock.run(until: 70_000)
|
|
539
|
+
await clock.run(until: 71_000)
|
|
540
|
+
#expect(engine.resolveAndLoadCalls.count == 3)
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
@Test func aPauseDuringAConnectHoldsItPastTheTimeout() async throws {
|
|
544
|
+
let (player, engine, clock) = try makeConnecting()
|
|
545
|
+
await clock.run(until: 10_000)
|
|
546
|
+
player.pause()
|
|
547
|
+
await clock.run(until: 200_000)
|
|
548
|
+
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
549
|
+
#expect(player.load?.reloadOnPlay == false)
|
|
550
|
+
#expect(player.state == .loading)
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
@Test func withRetryOffASilentConnectIsTerminalAtTheTimeout() async throws {
|
|
554
|
+
let (player, engine, clock) = try makeConnecting()
|
|
555
|
+
player.retry.updatePolicy(from: nil)
|
|
556
|
+
await clock.run(until: 29_999)
|
|
557
|
+
#expect(player.state == .loading)
|
|
558
|
+
await clock.run(until: 30_000)
|
|
559
|
+
#expect(player.state == .error)
|
|
560
|
+
#expect(player.errorStatus.error == .playbackStalled)
|
|
561
|
+
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
562
|
+
}
|
|
563
|
+
|
|
564
|
+
@Test func aPlayWhileConnectingWatchesTheConnect() async throws {
|
|
565
|
+
let (player, engine, clock) = try makeConnecting(playWhenReady: false)
|
|
566
|
+
await clock.run(until: 10_000)
|
|
567
|
+
player.play()
|
|
568
|
+
await clock.run(until: 41_000)
|
|
569
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
570
|
+
}
|
|
571
|
+
|
|
572
|
+
/// Ready and waiting for AVPlayer to start: its waiting is a stall, watched in .buffering.
|
|
573
|
+
@Test func aConnectThatIsReadyIsNoLongerWatched() async throws {
|
|
574
|
+
let (player, engine, clock) = try makeConnecting()
|
|
575
|
+
engine.hasItem = true
|
|
576
|
+
engine.hasLoadedAsset = true
|
|
577
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
578
|
+
#expect(player.state == .ready)
|
|
579
|
+
await clock.run(until: 100_000)
|
|
580
|
+
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
468
581
|
}
|
|
469
582
|
|
|
470
583
|
/// A link slower than the bitrate rebuffers for longer than the timeout, and a reload would
|
|
@@ -528,34 +641,147 @@ struct PlayerRecoveringTests {
|
|
|
528
641
|
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
529
642
|
}
|
|
530
643
|
|
|
531
|
-
@Test func
|
|
532
|
-
let
|
|
533
|
-
|
|
644
|
+
@Test func theDeadlineEndsASilentLoadInOneError_droppingTheConnectInFlight() async throws {
|
|
645
|
+
let clock = VirtualClock()
|
|
646
|
+
let retry = RetryLoop(clock: clock)
|
|
647
|
+
retry.updatePolicy(from: .first(true))
|
|
648
|
+
let engine = MockPlayerEngine()
|
|
649
|
+
let player = makePlayer(engine: engine, retry: retry)
|
|
650
|
+
let callbacks = MockPlayerCallbacks()
|
|
651
|
+
player.callbacks = callbacks
|
|
652
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
653
|
+
// The watch replaces the silent connect at 30 s, 1 s after it gives up on it; that failure
|
|
654
|
+
// brings the deadline to 42 s.
|
|
655
|
+
await clock.run(until: 31_000)
|
|
656
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
657
|
+
let cancels = engine.cancelLoadingCount, stops = engine.stopObservingItemCount
|
|
658
|
+
|
|
659
|
+
await clock.run(until: 41_999)
|
|
660
|
+
#expect(player.state == .loading)
|
|
661
|
+
await clock.run(until: 42_000)
|
|
662
|
+
|
|
663
|
+
#expect(player.state == .error)
|
|
664
|
+
#expect(player.errorStatus.error == .playbackStalled)
|
|
665
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
666
|
+
#expect(engine.cancelLoadingCount == cancels + 1)
|
|
667
|
+
#expect(engine.stopObservingItemCount == stops + 1)
|
|
668
|
+
}
|
|
669
|
+
|
|
670
|
+
/// The error pauses AVPlayer, and an item still connecting can report late: neither the pause,
|
|
671
|
+
/// nor its playing, nor its failure takes the state out of .error.
|
|
672
|
+
@Test func aTerminalErrorHoldsAgainstTheAVPlayersLateEvents() async throws {
|
|
673
|
+
let (player, engine, callbacks) = try makeStalling(givesUp: true)
|
|
674
|
+
engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
|
|
675
|
+
#expect(player.state == .error)
|
|
676
|
+
let loads = engine.resolveAndLoadCalls.count
|
|
677
|
+
|
|
678
|
+
engine.emit(.timeControlStatus(.paused, waitingForNoItem: false))
|
|
679
|
+
engine.emit(.timeControlStatus(.playing, waitingForNoItem: false))
|
|
680
|
+
engine.emit(.audioDidStart)
|
|
681
|
+
engine.emit(.failed(NSError(domain: "AVFoundationErrorDomain", code: -11800), httpStatusCode: nil))
|
|
682
|
+
await player.retry.pendingTask?.value
|
|
683
|
+
|
|
684
|
+
#expect(player.state == .error)
|
|
685
|
+
#expect(player.errorStatus.error == .playbackFailed)
|
|
686
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
687
|
+
#expect(player.retry.pendingTask == nil)
|
|
688
|
+
#expect(engine.resolveAndLoadCalls.count == loads)
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
/// The stalled connection ends with the network, before its return reaches the loop, so it
|
|
692
|
+
/// grows no backoff: only the 1 s floor applies, long past.
|
|
693
|
+
@Test func theNetworkReturningReconnectsAStalledStreamAtOnce() async throws {
|
|
694
|
+
let (player, engine, _, clock) = try makeVirtual(online: false)
|
|
534
695
|
player.transition(.avPlayerWaiting)
|
|
535
696
|
#expect(player.state == .buffering)
|
|
697
|
+
await clock.run(until: 5_000)
|
|
698
|
+
|
|
536
699
|
player.networkStatusDidChange(isOnline: true)
|
|
537
|
-
await
|
|
700
|
+
await clock.run(until: 5_000)
|
|
701
|
+
|
|
538
702
|
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
539
|
-
#expect(player.retry.attempts == 1)
|
|
540
703
|
}
|
|
541
704
|
|
|
542
|
-
|
|
705
|
+
/// The watch replaces the stall at 40 s at once, having played, then each silent connect 30 s
|
|
706
|
+
/// after it starts, 1 s and then 1.5 s later: the deadline still falls 120 s into the silence.
|
|
707
|
+
@Test func playbackThatStopsWithNoFailureEndsAtTheDeadline() async throws {
|
|
708
|
+
let (player, engine, callbacks, clock) = try makeVirtual()
|
|
709
|
+
player.transition(.avPlayerPlaying)
|
|
710
|
+
await clock.run(until: 10_000)
|
|
711
|
+
player.transition(.avPlayerWaiting)
|
|
712
|
+
|
|
713
|
+
await clock.run(until: 129_999)
|
|
714
|
+
#expect(player.state == .loading)
|
|
715
|
+
#expect(engine.resolveAndLoadCalls.count == 4)
|
|
716
|
+
await clock.run(until: 130_000)
|
|
717
|
+
#expect(player.state == .error)
|
|
718
|
+
#expect(player.errorStatus.error == .playbackStalled)
|
|
719
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
@Test func aRetryNowKeepsTheSilenceDeadline() async throws {
|
|
723
|
+
let (player, _, _, clock) = try makeVirtual()
|
|
724
|
+
// Its watch would end the reload's connect first.
|
|
725
|
+
player.retry.stallTimeout = .seconds(600)
|
|
726
|
+
await clock.run(until: 60_000)
|
|
727
|
+
player.retryNow()
|
|
728
|
+
|
|
729
|
+
await clock.run(until: 119_999)
|
|
730
|
+
#expect(player.state != .error)
|
|
731
|
+
await clock.run(until: 120_000)
|
|
732
|
+
#expect(player.state == .error)
|
|
733
|
+
}
|
|
734
|
+
|
|
735
|
+
@Test func hasPlayedSurvivesAPark_aRetryNowAndAMediaReset() async throws {
|
|
736
|
+
let engine = MockPlayerEngine()
|
|
737
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
738
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
739
|
+
engine.hasItem = true
|
|
740
|
+
engine.hasLoadedAsset = true
|
|
741
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
742
|
+
player.transition(.avPlayerPlaying)
|
|
743
|
+
#expect(player.retry.hasPlayed)
|
|
744
|
+
|
|
745
|
+
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
746
|
+
player.pause()
|
|
747
|
+
#expect(player.state == .paused)
|
|
748
|
+
player.play()
|
|
749
|
+
player.retryNow()
|
|
750
|
+
player.mediaServicesWereReset()
|
|
751
|
+
|
|
752
|
+
#expect(player.retry.hasPlayed)
|
|
753
|
+
player.retry.cancel()
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
@Test func aRateChangeInAnErrorLeavesTheAbandonedItemPaused() throws {
|
|
757
|
+
let (player, engine, _) = try makePlaying()
|
|
758
|
+
engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
|
|
759
|
+
#expect(player.state == .error)
|
|
760
|
+
#expect(player.playWhenReady)
|
|
761
|
+
|
|
762
|
+
player.rate = 1.5
|
|
763
|
+
|
|
764
|
+
#expect(engine.rates.last?.rate == 1.5)
|
|
765
|
+
#expect(engine.rates.last?.playing == false)
|
|
766
|
+
}
|
|
767
|
+
|
|
768
|
+
/// `maxRetries` counts connections in a row that delivered nothing; one that plays between
|
|
769
|
+
/// flaps starts it over, and only the silence deadline bounds it (docs/adr/0014).
|
|
770
|
+
@Test func aFlappingConnectionThatPlaysBetweenKeepsReconnecting() async throws {
|
|
543
771
|
let (player, engine, callbacks) = try makePlaying()
|
|
544
772
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
545
773
|
maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
546
774
|
)))
|
|
547
|
-
|
|
548
|
-
for flap in 1 ... 3 {
|
|
775
|
+
for _ in 1 ... 5 {
|
|
549
776
|
player.transition(.avPlayerWaiting)
|
|
550
777
|
player.networkStatusDidChange(isOnline: true)
|
|
551
778
|
await player.retry.pendingTask?.value
|
|
552
|
-
if flap == 3 { break }
|
|
553
779
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
554
780
|
player.transition(.avPlayerPlaying)
|
|
555
781
|
}
|
|
556
|
-
#expect(engine.resolveAndLoadCalls.count ==
|
|
557
|
-
#expect(player.state == .
|
|
558
|
-
#expect(callbacks.errorEvents.
|
|
782
|
+
#expect(engine.resolveAndLoadCalls.count == 6)
|
|
783
|
+
#expect(player.state == .playing)
|
|
784
|
+
#expect(callbacks.errorEvents.isEmpty)
|
|
559
785
|
}
|
|
560
786
|
|
|
561
787
|
@Test func theNetworkReturningWithRetryOffLeavesTheStallToAVPlayer() throws {
|
|
@@ -578,7 +804,7 @@ struct PlayerRecoveringTests {
|
|
|
578
804
|
|
|
579
805
|
@Test func theNetworkReturningDuringABackoffLeavesTheReloadToTheRetry() async throws {
|
|
580
806
|
let engine = MockPlayerEngine()
|
|
581
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05)
|
|
807
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
582
808
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")])
|
|
583
809
|
player.play()
|
|
584
810
|
player.transition(.avPlayerWaiting)
|
|
@@ -606,7 +832,6 @@ struct PlayerRecoveringTests {
|
|
|
606
832
|
|
|
607
833
|
@Test func theNetworkReturningReRendersBeforeReconnecting() async throws {
|
|
608
834
|
let (player, engine, _) = try makePlaying()
|
|
609
|
-
player.retry.shouldRetry = { true }
|
|
610
835
|
player.transition(.avPlayerWaiting)
|
|
611
836
|
var order: [String] = []
|
|
612
837
|
engine.onSeamCall = { order.append($0) }
|
|
@@ -623,21 +848,20 @@ struct PlayerRecoveringTests {
|
|
|
623
848
|
let (player, engine, _) = try makePlaying()
|
|
624
849
|
engine.emit(.audioDidStart)
|
|
625
850
|
let first = player.load
|
|
626
|
-
#expect(
|
|
851
|
+
#expect(player.retry.hasPlayed)
|
|
627
852
|
|
|
628
853
|
engine.emit(.unplayable)
|
|
629
854
|
#expect(player.state == .error)
|
|
630
855
|
player.play()
|
|
631
856
|
|
|
632
857
|
#expect(player.load?.id != first?.id)
|
|
633
|
-
#expect(player.
|
|
858
|
+
#expect(!player.retry.hasPlayed)
|
|
634
859
|
#expect(player.load?.primedNowPlaying == false)
|
|
635
860
|
#expect(engine.recreateCount == 1)
|
|
636
861
|
}
|
|
637
862
|
|
|
638
863
|
@Test func aRetryKeepsItsLoad() async throws {
|
|
639
864
|
let (player, engine, _) = try makePlaying()
|
|
640
|
-
player.retry.shouldRetry = { true }
|
|
641
865
|
let first = player.load
|
|
642
866
|
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
643
867
|
await player.retry.pendingTask?.value
|
|
@@ -647,7 +871,6 @@ struct PlayerRecoveringTests {
|
|
|
647
871
|
|
|
648
872
|
@Test func aRetryAfterTheAVPlayerItselfFailedReloadsOnANewOne_inTheSameLoad() async throws {
|
|
649
873
|
let (player, engine, _) = try makePlaying()
|
|
650
|
-
player.retry.shouldRetry = { true }
|
|
651
874
|
engine.emit(.audioDidStart)
|
|
652
875
|
let first = player.load
|
|
653
876
|
engine.playerFailed = true
|
|
@@ -658,12 +881,12 @@ struct PlayerRecoveringTests {
|
|
|
658
881
|
#expect(engine.recreateCount == 1)
|
|
659
882
|
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
660
883
|
#expect(player.load?.id == first?.id)
|
|
661
|
-
#expect(player.
|
|
884
|
+
#expect(player.retry.hasPlayed)
|
|
662
885
|
}
|
|
663
886
|
|
|
664
887
|
@Test func aMediaServicesResetDuringABackoffReloadsOnce() async throws {
|
|
665
888
|
let engine = MockPlayerEngine()
|
|
666
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05)
|
|
889
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
667
890
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
668
891
|
engine.hasItem = true
|
|
669
892
|
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
@@ -774,7 +997,7 @@ struct PlayerReviewRegressionTests {
|
|
|
774
997
|
@Test func aRestartFromAnErrorDuringTheStartSeekKeepsTheStart() throws {
|
|
775
998
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
776
999
|
let engine = MockPlayerEngine()
|
|
777
|
-
let player = makePlayer(engine: engine
|
|
1000
|
+
let player = makePlayer(engine: engine)
|
|
778
1001
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
779
1002
|
engine.seekResult = nil
|
|
780
1003
|
engine.hasItem = true
|
|
@@ -794,7 +1017,7 @@ struct PlayerReviewRegressionTests {
|
|
|
794
1017
|
|
|
795
1018
|
@Test func aSeekInAnErrorDuringTheStartSeekReplacesTheStart() throws {
|
|
796
1019
|
let engine = MockPlayerEngine()
|
|
797
|
-
let player = makePlayer(engine: engine
|
|
1020
|
+
let player = makePlayer(engine: engine)
|
|
798
1021
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
799
1022
|
engine.seekResult = nil
|
|
800
1023
|
engine.hasItem = true
|
|
@@ -884,7 +1107,7 @@ struct PlayerReviewRegressionTests {
|
|
|
884
1107
|
|
|
885
1108
|
@Test func aStartPositionIsSavedWithTheTrackChange() throws {
|
|
886
1109
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
887
|
-
let player = makePlayer(
|
|
1110
|
+
let player = makePlayer()
|
|
888
1111
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
|
|
889
1112
|
let saved = PlaybackPersistence(defaults: UserDefaults(suiteName: "PlayerTests")!) { nil }.load()
|
|
890
1113
|
#expect(saved?.positionMs == 30000)
|
|
@@ -920,7 +1143,7 @@ struct PlayerReviewRegressionTests {
|
|
|
920
1143
|
@Test func playingSavesPeriodically() async throws {
|
|
921
1144
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
922
1145
|
let engine = MockPlayerEngine()
|
|
923
|
-
let player = makePlayer(engine: engine,
|
|
1146
|
+
let player = makePlayer(engine: engine, saveInterval: .milliseconds(10))
|
|
924
1147
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
925
1148
|
engine.hasItem = true
|
|
926
1149
|
engine.hasLoadedAsset = true
|
|
@@ -944,7 +1167,7 @@ struct PlayerReviewRegressionTests {
|
|
|
944
1167
|
)
|
|
945
1168
|
PlaybackPersistence(defaults: defaults) { saved }.save()
|
|
946
1169
|
|
|
947
|
-
let player = makePlayer(
|
|
1170
|
+
let player = makePlayer()
|
|
948
1171
|
let session = try #require(player.persistedSession())
|
|
949
1172
|
player.resume(session, queue: nil)
|
|
950
1173
|
#expect(player.currentTrack?.id == "t1")
|
|
@@ -962,12 +1185,11 @@ struct PlayerReviewRegressionTests {
|
|
|
962
1185
|
positionMs: nil, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1,
|
|
963
1186
|
)
|
|
964
1187
|
PlaybackPersistence(defaults: defaults) { saved }.save()
|
|
965
|
-
#expect(makePlayer(
|
|
1188
|
+
#expect(makePlayer().persistedSession() == nil)
|
|
966
1189
|
}
|
|
967
1190
|
|
|
968
1191
|
@Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async throws {
|
|
969
1192
|
let (player, engine, callbacks) = try makeLoading()
|
|
970
|
-
player.retry.shouldRetry = { true }
|
|
971
1193
|
player.setPlayWhenReady(true)
|
|
972
1194
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
973
1195
|
#expect(callbacks.playbackChanges.last?.error != nil)
|