react-native-audio-browser 0.2.0-next.81 → 0.2.0-next.82
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/PlaybackStateMachine.swift +4 -3
- package/ios/Player/Player.swift +31 -18
- package/ios/Player/RetryLoop.swift +186 -193
- 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 +163 -50
- package/ios/Tests/PlayerTests.swift +11 -85
- package/ios/Tests/RetryLoopTests.swift +296 -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,23 @@ 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
|
+
|
|
48
65
|
@Suite("Player - seeking")
|
|
49
66
|
@MainActor
|
|
50
67
|
struct PlayerSeekingTests {
|
|
@@ -95,7 +112,7 @@ struct PlayerSeekingTests {
|
|
|
95
112
|
|
|
96
113
|
@Test func aCompletionFromBeforeAReloadIsDropped() throws {
|
|
97
114
|
let engine = MockPlayerEngine()
|
|
98
|
-
let player = makePlayer(engine: engine
|
|
115
|
+
let player = makePlayer(engine: engine)
|
|
99
116
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
100
117
|
engine.seekResult = nil
|
|
101
118
|
engine.hasItem = true
|
|
@@ -114,7 +131,7 @@ struct PlayerSeekingTests {
|
|
|
114
131
|
|
|
115
132
|
@Test func aStartSeekCutShortWaitsForTheNextItem() throws {
|
|
116
133
|
let engine = MockPlayerEngine()
|
|
117
|
-
let player = makePlayer(engine: engine
|
|
134
|
+
let player = makePlayer(engine: engine)
|
|
118
135
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
119
136
|
engine.seekResult = nil
|
|
120
137
|
engine.hasItem = true
|
|
@@ -130,7 +147,7 @@ struct PlayerSeekingTests {
|
|
|
130
147
|
/// A media-load retry passes no position, so the start in flight is what it resumes from.
|
|
131
148
|
@Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
|
|
132
149
|
let engine = MockPlayerEngine()
|
|
133
|
-
let player = makePlayer(engine: engine
|
|
150
|
+
let player = makePlayer(engine: engine)
|
|
134
151
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
135
152
|
engine.seekResult = nil
|
|
136
153
|
engine.hasItem = true
|
|
@@ -146,7 +163,7 @@ struct PlayerSeekingTests {
|
|
|
146
163
|
|
|
147
164
|
@Test func aMediaServicesResetDuringTheLoadKeepsTheStart() throws {
|
|
148
165
|
let engine = MockPlayerEngine()
|
|
149
|
-
let player = makePlayer(engine: engine
|
|
166
|
+
let player = makePlayer(engine: engine)
|
|
150
167
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
151
168
|
|
|
152
169
|
player.mediaServicesWereReset()
|
|
@@ -158,7 +175,7 @@ struct PlayerSeekingTests {
|
|
|
158
175
|
|
|
159
176
|
@Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
|
|
160
177
|
let engine = MockPlayerEngine()
|
|
161
|
-
let player = makePlayer(engine: engine
|
|
178
|
+
let player = makePlayer(engine: engine)
|
|
162
179
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
163
180
|
engine.seekResult = nil
|
|
164
181
|
engine.hasItem = true
|
|
@@ -174,7 +191,7 @@ struct PlayerSeekingTests {
|
|
|
174
191
|
|
|
175
192
|
@Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
|
|
176
193
|
let engine = MockPlayerEngine()
|
|
177
|
-
let player = makePlayer(engine: engine
|
|
194
|
+
let player = makePlayer(engine: engine)
|
|
178
195
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
|
|
179
196
|
engine.seekResult = nil
|
|
180
197
|
engine.hasItem = true
|
|
@@ -220,7 +237,6 @@ struct PlayerEngineEventTests {
|
|
|
220
237
|
@Test func aFailedLoadPrimesNowPlayingOncePerLoad() throws {
|
|
221
238
|
let (player, engine, _) = try makeLoading()
|
|
222
239
|
player.setPlayWhenReady(true)
|
|
223
|
-
player.retry.shouldRetry = { true }
|
|
224
240
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
225
241
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
226
242
|
#expect(engine.primeCount == 1)
|
|
@@ -286,18 +302,15 @@ struct PlayerEngineEventTests {
|
|
|
286
302
|
#expect(player.state == .ended)
|
|
287
303
|
|
|
288
304
|
let (live, liveEngine, _) = try makePlaying(live: true)
|
|
289
|
-
live.retry.shouldRetry = { true }
|
|
290
305
|
liveEngine.emit(.playedToEnd)
|
|
291
306
|
await live.retry.pendingTask?.value
|
|
292
307
|
#expect(live.state == .loading)
|
|
293
308
|
#expect(liveEngine.resolveAndLoadCalls.count == 2)
|
|
294
|
-
#expect(live.retry.attempts == 1)
|
|
295
309
|
}
|
|
296
310
|
|
|
297
311
|
/// AVPlayer pauses an item at its end, so a seek within its window would leave it silent.
|
|
298
312
|
@Test func aLiveEndReconnectsEvenWithASeekableWindow() async throws {
|
|
299
313
|
let (player, engine, _) = try makePlaying(live: true)
|
|
300
|
-
player.retry.shouldRetry = { true }
|
|
301
314
|
engine.liveEdge = 120
|
|
302
315
|
engine.emit(.playedToEnd)
|
|
303
316
|
await player.retry.pendingTask?.value
|
|
@@ -310,34 +323,30 @@ struct PlayerEngineEventTests {
|
|
|
310
323
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
311
324
|
maxRetries: 3, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
312
325
|
)))
|
|
313
|
-
player.retry.shouldRetry = { true }
|
|
314
326
|
for _ in 0 ..< 20 where player.state != .error {
|
|
315
327
|
engine.emit(.playedToEnd)
|
|
316
328
|
await player.retry.pendingTask?.value
|
|
329
|
+
engine.hasLoadedAsset = true
|
|
317
330
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
318
331
|
}
|
|
319
|
-
|
|
332
|
+
// The first connection played, so its end starts the count: four that deliver nothing follow.
|
|
333
|
+
#expect(engine.resolveAndLoadCalls.count == 5)
|
|
320
334
|
#expect(player.state == .error)
|
|
321
335
|
#expect(player.errorStatus.error == .playbackStalled)
|
|
322
336
|
#expect(callbacks.errorEvents.count == 1)
|
|
323
337
|
}
|
|
324
338
|
|
|
325
|
-
///
|
|
326
|
-
@Test func
|
|
339
|
+
/// A connection that delivered audio starts `maxRetries`' count over (docs/adr/0014).
|
|
340
|
+
@Test func liveEndsBetweenAudioNeverSpendMaxRetries() async throws {
|
|
327
341
|
let (player, engine, callbacks) = try makePlaying(live: true)
|
|
328
342
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
329
343
|
maxRetries: 1, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
330
344
|
)))
|
|
331
|
-
player.retry.shouldRetry = { true }
|
|
332
|
-
player.retry.healthyPlaybackDuration = .milliseconds(10)
|
|
333
345
|
for _ in 0 ..< 5 {
|
|
334
346
|
engine.emit(.playedToEnd)
|
|
335
347
|
await player.retry.pendingTask?.value
|
|
336
|
-
#expect(player.retry.attempts == 1)
|
|
337
348
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
338
349
|
player.transition(.avPlayerPlaying)
|
|
339
|
-
await player.retry.healthyPlaybackTask?.value
|
|
340
|
-
#expect(player.retry.attempts == 0)
|
|
341
350
|
}
|
|
342
351
|
#expect(engine.resolveAndLoadCalls.count == 6)
|
|
343
352
|
#expect(player.state == .playing)
|
|
@@ -357,7 +366,6 @@ struct PlayerEngineEventTests {
|
|
|
357
366
|
/// The engine stops observing an item on a reload; a played-to-end it delivered late is stale.
|
|
358
367
|
@Test func aPlayedToEndDuringALoadIsIgnored() throws {
|
|
359
368
|
let (player, engine, _) = try makePlaying(live: true)
|
|
360
|
-
player.retry.shouldRetry = { true }
|
|
361
369
|
player.reloadResolving(startFromCurrentTime: false)
|
|
362
370
|
#expect(player.state == .loading)
|
|
363
371
|
engine.emit(.playedToEnd)
|
|
@@ -416,7 +424,12 @@ struct PlayerRecoveringTests {
|
|
|
416
424
|
}
|
|
417
425
|
|
|
418
426
|
@Test func aStallWithNoFailureEndsInPlaybackStalledOnceTheBudgetIsSpent() async throws {
|
|
419
|
-
let (player,
|
|
427
|
+
let (player, engine, callbacks) = try makeStalling(givesUp: true)
|
|
428
|
+
await player.retry.stallTask?.value
|
|
429
|
+
await player.retry.pendingTask?.value
|
|
430
|
+
// The stalled connection had played, so even `maxRetries: 0` reconnects it once.
|
|
431
|
+
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
432
|
+
player.transition(.avPlayerWaiting)
|
|
420
433
|
await player.retry.stallTask?.value
|
|
421
434
|
await player.retry.pendingTask?.value
|
|
422
435
|
#expect(player.state == .error)
|
|
@@ -528,34 +541,138 @@ struct PlayerRecoveringTests {
|
|
|
528
541
|
#expect(engine.resolveAndLoadCalls.count == 1)
|
|
529
542
|
}
|
|
530
543
|
|
|
531
|
-
@Test func
|
|
532
|
-
let
|
|
533
|
-
|
|
544
|
+
@Test func theDeadlineEndsASilentLoadInOneError_droppingTheConnectInFlight() async throws {
|
|
545
|
+
let clock = VirtualClock()
|
|
546
|
+
let retry = RetryLoop(clock: clock)
|
|
547
|
+
retry.updatePolicy(from: .first(true))
|
|
548
|
+
let engine = MockPlayerEngine()
|
|
549
|
+
let player = makePlayer(engine: engine, retry: retry)
|
|
550
|
+
let callbacks = MockPlayerCallbacks()
|
|
551
|
+
player.callbacks = callbacks
|
|
552
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
553
|
+
let cancels = engine.cancelLoadingCount, stops = engine.stopObservingItemCount
|
|
554
|
+
|
|
555
|
+
await clock.run(until: 119_999)
|
|
556
|
+
#expect(player.state == .loading)
|
|
557
|
+
await clock.run(until: 120_000)
|
|
558
|
+
|
|
559
|
+
#expect(player.state == .error)
|
|
560
|
+
#expect(player.errorStatus.error == .playbackStalled)
|
|
561
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
562
|
+
#expect(engine.cancelLoadingCount == cancels + 1)
|
|
563
|
+
#expect(engine.stopObservingItemCount == stops + 1)
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
/// The error pauses AVPlayer, and an item still connecting can report late: neither the pause,
|
|
567
|
+
/// nor its playing, nor its failure takes the state out of .error.
|
|
568
|
+
@Test func aTerminalErrorHoldsAgainstTheAVPlayersLateEvents() async throws {
|
|
569
|
+
let (player, engine, callbacks) = try makeStalling(givesUp: true)
|
|
570
|
+
engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
|
|
571
|
+
#expect(player.state == .error)
|
|
572
|
+
let loads = engine.resolveAndLoadCalls.count
|
|
573
|
+
|
|
574
|
+
engine.emit(.timeControlStatus(.paused, waitingForNoItem: false))
|
|
575
|
+
engine.emit(.timeControlStatus(.playing, waitingForNoItem: false))
|
|
576
|
+
engine.emit(.audioDidStart)
|
|
577
|
+
engine.emit(.failed(NSError(domain: "AVFoundationErrorDomain", code: -11800), httpStatusCode: nil))
|
|
578
|
+
await player.retry.pendingTask?.value
|
|
579
|
+
|
|
580
|
+
#expect(player.state == .error)
|
|
581
|
+
#expect(player.errorStatus.error == .playbackFailed)
|
|
582
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
583
|
+
#expect(player.retry.pendingTask == nil)
|
|
584
|
+
#expect(engine.resolveAndLoadCalls.count == loads)
|
|
585
|
+
}
|
|
586
|
+
|
|
587
|
+
/// The stalled connection ends with the network, before its return reaches the loop, so it
|
|
588
|
+
/// grows no backoff: only the 1 s floor applies, long past.
|
|
589
|
+
@Test func theNetworkReturningReconnectsAStalledStreamAtOnce() async throws {
|
|
590
|
+
let (player, engine, _, clock) = try makeVirtual(online: false)
|
|
534
591
|
player.transition(.avPlayerWaiting)
|
|
535
592
|
#expect(player.state == .buffering)
|
|
593
|
+
await clock.run(until: 5_000)
|
|
594
|
+
|
|
536
595
|
player.networkStatusDidChange(isOnline: true)
|
|
537
|
-
await
|
|
596
|
+
await clock.run(until: 5_000)
|
|
597
|
+
|
|
538
598
|
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
539
|
-
#expect(player.retry.attempts == 1)
|
|
540
599
|
}
|
|
541
600
|
|
|
542
|
-
@Test func
|
|
601
|
+
@Test func playbackThatStopsWithNoFailureEndsAtTheDeadline() async throws {
|
|
602
|
+
let (player, _, callbacks, clock) = try makeVirtual()
|
|
603
|
+
player.transition(.avPlayerPlaying)
|
|
604
|
+
await clock.run(until: 10_000)
|
|
605
|
+
player.transition(.avPlayerWaiting)
|
|
606
|
+
|
|
607
|
+
await clock.run(until: 129_999)
|
|
608
|
+
#expect(player.state == .buffering)
|
|
609
|
+
await clock.run(until: 130_000)
|
|
610
|
+
#expect(player.state == .error)
|
|
611
|
+
#expect(player.errorStatus.error == .playbackStalled)
|
|
612
|
+
#expect(callbacks.errorEvents.count == 1)
|
|
613
|
+
}
|
|
614
|
+
|
|
615
|
+
@Test func aRetryNowKeepsTheSilenceDeadline() async throws {
|
|
616
|
+
let (player, _, _, clock) = try makeVirtual()
|
|
617
|
+
await clock.run(until: 60_000)
|
|
618
|
+
player.retryNow()
|
|
619
|
+
|
|
620
|
+
await clock.run(until: 119_999)
|
|
621
|
+
#expect(player.state != .error)
|
|
622
|
+
await clock.run(until: 120_000)
|
|
623
|
+
#expect(player.state == .error)
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
@Test func hasPlayedSurvivesAPark_aRetryNowAndAMediaReset() async throws {
|
|
627
|
+
let engine = MockPlayerEngine()
|
|
628
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
629
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
630
|
+
engine.hasItem = true
|
|
631
|
+
engine.hasLoadedAsset = true
|
|
632
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
633
|
+
player.transition(.avPlayerPlaying)
|
|
634
|
+
#expect(player.retry.hasPlayed)
|
|
635
|
+
|
|
636
|
+
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
637
|
+
player.pause()
|
|
638
|
+
#expect(player.state == .paused)
|
|
639
|
+
player.play()
|
|
640
|
+
player.retryNow()
|
|
641
|
+
player.mediaServicesWereReset()
|
|
642
|
+
|
|
643
|
+
#expect(player.retry.hasPlayed)
|
|
644
|
+
player.retry.cancel()
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
@Test func aRateChangeInAnErrorLeavesTheAbandonedItemPaused() throws {
|
|
648
|
+
let (player, engine, _) = try makePlaying()
|
|
649
|
+
engine.emit(.failed(URLError(.badURL), httpStatusCode: nil))
|
|
650
|
+
#expect(player.state == .error)
|
|
651
|
+
#expect(player.playWhenReady)
|
|
652
|
+
|
|
653
|
+
player.rate = 1.5
|
|
654
|
+
|
|
655
|
+
#expect(engine.rates.last?.rate == 1.5)
|
|
656
|
+
#expect(engine.rates.last?.playing == false)
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
/// `maxRetries` counts connections in a row that delivered nothing; one that plays between
|
|
660
|
+
/// flaps starts it over, and only the silence deadline bounds it (docs/adr/0014).
|
|
661
|
+
@Test func aFlappingConnectionThatPlaysBetweenKeepsReconnecting() async throws {
|
|
543
662
|
let (player, engine, callbacks) = try makePlaying()
|
|
544
663
|
player.retry.updatePolicy(from: .second(RetryConfig(
|
|
545
664
|
maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
546
665
|
)))
|
|
547
|
-
|
|
548
|
-
for flap in 1 ... 3 {
|
|
666
|
+
for _ in 1 ... 5 {
|
|
549
667
|
player.transition(.avPlayerWaiting)
|
|
550
668
|
player.networkStatusDidChange(isOnline: true)
|
|
551
669
|
await player.retry.pendingTask?.value
|
|
552
|
-
if flap == 3 { break }
|
|
553
670
|
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
554
671
|
player.transition(.avPlayerPlaying)
|
|
555
672
|
}
|
|
556
|
-
#expect(engine.resolveAndLoadCalls.count ==
|
|
557
|
-
#expect(player.state == .
|
|
558
|
-
#expect(callbacks.errorEvents.
|
|
673
|
+
#expect(engine.resolveAndLoadCalls.count == 6)
|
|
674
|
+
#expect(player.state == .playing)
|
|
675
|
+
#expect(callbacks.errorEvents.isEmpty)
|
|
559
676
|
}
|
|
560
677
|
|
|
561
678
|
@Test func theNetworkReturningWithRetryOffLeavesTheStallToAVPlayer() throws {
|
|
@@ -578,7 +695,7 @@ struct PlayerRecoveringTests {
|
|
|
578
695
|
|
|
579
696
|
@Test func theNetworkReturningDuringABackoffLeavesTheReloadToTheRetry() async throws {
|
|
580
697
|
let engine = MockPlayerEngine()
|
|
581
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05)
|
|
698
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
582
699
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")])
|
|
583
700
|
player.play()
|
|
584
701
|
player.transition(.avPlayerWaiting)
|
|
@@ -606,7 +723,6 @@ struct PlayerRecoveringTests {
|
|
|
606
723
|
|
|
607
724
|
@Test func theNetworkReturningReRendersBeforeReconnecting() async throws {
|
|
608
725
|
let (player, engine, _) = try makePlaying()
|
|
609
|
-
player.retry.shouldRetry = { true }
|
|
610
726
|
player.transition(.avPlayerWaiting)
|
|
611
727
|
var order: [String] = []
|
|
612
728
|
engine.onSeamCall = { order.append($0) }
|
|
@@ -623,21 +739,20 @@ struct PlayerRecoveringTests {
|
|
|
623
739
|
let (player, engine, _) = try makePlaying()
|
|
624
740
|
engine.emit(.audioDidStart)
|
|
625
741
|
let first = player.load
|
|
626
|
-
#expect(
|
|
742
|
+
#expect(player.retry.hasPlayed)
|
|
627
743
|
|
|
628
744
|
engine.emit(.unplayable)
|
|
629
745
|
#expect(player.state == .error)
|
|
630
746
|
player.play()
|
|
631
747
|
|
|
632
748
|
#expect(player.load?.id != first?.id)
|
|
633
|
-
#expect(player.
|
|
749
|
+
#expect(!player.retry.hasPlayed)
|
|
634
750
|
#expect(player.load?.primedNowPlaying == false)
|
|
635
751
|
#expect(engine.recreateCount == 1)
|
|
636
752
|
}
|
|
637
753
|
|
|
638
754
|
@Test func aRetryKeepsItsLoad() async throws {
|
|
639
755
|
let (player, engine, _) = try makePlaying()
|
|
640
|
-
player.retry.shouldRetry = { true }
|
|
641
756
|
let first = player.load
|
|
642
757
|
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
643
758
|
await player.retry.pendingTask?.value
|
|
@@ -647,7 +762,6 @@ struct PlayerRecoveringTests {
|
|
|
647
762
|
|
|
648
763
|
@Test func aRetryAfterTheAVPlayerItselfFailedReloadsOnANewOne_inTheSameLoad() async throws {
|
|
649
764
|
let (player, engine, _) = try makePlaying()
|
|
650
|
-
player.retry.shouldRetry = { true }
|
|
651
765
|
engine.emit(.audioDidStart)
|
|
652
766
|
let first = player.load
|
|
653
767
|
engine.playerFailed = true
|
|
@@ -658,12 +772,12 @@ struct PlayerRecoveringTests {
|
|
|
658
772
|
#expect(engine.recreateCount == 1)
|
|
659
773
|
#expect(engine.resolveAndLoadCalls.count == 2)
|
|
660
774
|
#expect(player.load?.id == first?.id)
|
|
661
|
-
#expect(player.
|
|
775
|
+
#expect(player.retry.hasPlayed)
|
|
662
776
|
}
|
|
663
777
|
|
|
664
778
|
@Test func aMediaServicesResetDuringABackoffReloadsOnce() async throws {
|
|
665
779
|
let engine = MockPlayerEngine()
|
|
666
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05)
|
|
780
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
667
781
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
668
782
|
engine.hasItem = true
|
|
669
783
|
engine.emit(.failed(URLError(.timedOut), httpStatusCode: nil))
|
|
@@ -774,7 +888,7 @@ struct PlayerReviewRegressionTests {
|
|
|
774
888
|
@Test func aRestartFromAnErrorDuringTheStartSeekKeepsTheStart() throws {
|
|
775
889
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
776
890
|
let engine = MockPlayerEngine()
|
|
777
|
-
let player = makePlayer(engine: engine
|
|
891
|
+
let player = makePlayer(engine: engine)
|
|
778
892
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
779
893
|
engine.seekResult = nil
|
|
780
894
|
engine.hasItem = true
|
|
@@ -794,7 +908,7 @@ struct PlayerReviewRegressionTests {
|
|
|
794
908
|
|
|
795
909
|
@Test func aSeekInAnErrorDuringTheStartSeekReplacesTheStart() throws {
|
|
796
910
|
let engine = MockPlayerEngine()
|
|
797
|
-
let player = makePlayer(engine: engine
|
|
911
|
+
let player = makePlayer(engine: engine)
|
|
798
912
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
799
913
|
engine.seekResult = nil
|
|
800
914
|
engine.hasItem = true
|
|
@@ -884,7 +998,7 @@ struct PlayerReviewRegressionTests {
|
|
|
884
998
|
|
|
885
999
|
@Test func aStartPositionIsSavedWithTheTrackChange() throws {
|
|
886
1000
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
887
|
-
let player = makePlayer(
|
|
1001
|
+
let player = makePlayer()
|
|
888
1002
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")], startPositionMs: 30000)
|
|
889
1003
|
let saved = PlaybackPersistence(defaults: UserDefaults(suiteName: "PlayerTests")!) { nil }.load()
|
|
890
1004
|
#expect(saved?.positionMs == 30000)
|
|
@@ -920,7 +1034,7 @@ struct PlayerReviewRegressionTests {
|
|
|
920
1034
|
@Test func playingSavesPeriodically() async throws {
|
|
921
1035
|
UserDefaults(suiteName: "PlayerTests")!.removePersistentDomain(forName: "PlayerTests")
|
|
922
1036
|
let engine = MockPlayerEngine()
|
|
923
|
-
let player = makePlayer(engine: engine,
|
|
1037
|
+
let player = makePlayer(engine: engine, saveInterval: .milliseconds(10))
|
|
924
1038
|
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], playWhenReady: true)
|
|
925
1039
|
engine.hasItem = true
|
|
926
1040
|
engine.hasLoadedAsset = true
|
|
@@ -944,7 +1058,7 @@ struct PlayerReviewRegressionTests {
|
|
|
944
1058
|
)
|
|
945
1059
|
PlaybackPersistence(defaults: defaults) { saved }.save()
|
|
946
1060
|
|
|
947
|
-
let player = makePlayer(
|
|
1061
|
+
let player = makePlayer()
|
|
948
1062
|
let session = try #require(player.persistedSession())
|
|
949
1063
|
player.resume(session, queue: nil)
|
|
950
1064
|
#expect(player.currentTrack?.id == "t1")
|
|
@@ -962,12 +1076,11 @@ struct PlayerReviewRegressionTests {
|
|
|
962
1076
|
positionMs: nil, repeatMode: "off", shuffleEnabled: false, playbackSpeed: 1,
|
|
963
1077
|
)
|
|
964
1078
|
PlaybackPersistence(defaults: defaults) { saved }.save()
|
|
965
|
-
#expect(makePlayer(
|
|
1079
|
+
#expect(makePlayer().persistedSession() == nil)
|
|
966
1080
|
}
|
|
967
1081
|
|
|
968
1082
|
@Test func aTrackChangeClearsTheRetryingErrorOfTheTrackItLeaves() async throws {
|
|
969
1083
|
let (player, engine, callbacks) = try makeLoading()
|
|
970
|
-
player.retry.shouldRetry = { true }
|
|
971
1084
|
player.setPlayWhenReady(true)
|
|
972
1085
|
engine.emit(.loadFailed(URLError(.timedOut)))
|
|
973
1086
|
#expect(callbacks.playbackChanges.last?.error != nil)
|
|
@@ -11,7 +11,7 @@ private func makeCoordinator() -> (
|
|
|
11
11
|
) {
|
|
12
12
|
let clock = ManualSleepTimerScheduler()
|
|
13
13
|
let engine = MockPlayerEngine()
|
|
14
|
-
let player = makePlayer(engine: engine,
|
|
14
|
+
let player = makePlayer(engine: engine, sleepTimerScheduler: clock)
|
|
15
15
|
let callbacks = MockPlayerCallbacks()
|
|
16
16
|
player.callbacks = callbacks
|
|
17
17
|
return (player, engine, callbacks, clock)
|
|
@@ -113,6 +113,8 @@ private func makeRetrying() -> (
|
|
|
113
113
|
let retryHandler = makeRetryLoop()
|
|
114
114
|
let engine = MockPlayerEngine()
|
|
115
115
|
let player = makePlayer(engine: engine, retry: retryHandler)
|
|
116
|
+
// The loop's intent alone, so a test drives the states without the engine calls a play makes.
|
|
117
|
+
retryHandler.playIntentChanged(true)
|
|
116
118
|
let callbacks = MockPlayerCallbacks()
|
|
117
119
|
player.callbacks = callbacks
|
|
118
120
|
return (player, retryHandler, callbacks, engine)
|
|
@@ -192,6 +194,8 @@ struct RetryingErrorTests {
|
|
|
192
194
|
c.retry.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
|
|
193
195
|
await c.retry.pendingTask?.value
|
|
194
196
|
|
|
197
|
+
// With no track, the reload starts no connection: the second failure needs one of its own.
|
|
198
|
+
c.retry.connectionStarted()
|
|
195
199
|
c.retry.handleError(URLError(.cannotConnectToHost), context: .mediaLoad)
|
|
196
200
|
await c.retry.pendingTask?.value
|
|
197
201
|
|
|
@@ -254,14 +258,12 @@ struct RetryingErrorTests {
|
|
|
254
258
|
maxRetries: 2, maxRetryDurationMs: nil, firstConnectMaxRetryDurationMs: nil,
|
|
255
259
|
)))
|
|
256
260
|
let stall = NSError(domain: "CoreMediaErrorDomain", code: -16830)
|
|
257
|
-
// One retry spent before the pause; the
|
|
261
|
+
// One retry spent before the pause; the play after it starts the count over.
|
|
258
262
|
eh.emit(.failed(stall, httpStatusCode: nil))
|
|
259
263
|
await c.retry.pendingTask?.value
|
|
260
|
-
#expect(c.retry.attempts == 1)
|
|
261
264
|
|
|
262
265
|
c.pause()
|
|
263
266
|
eh.emit(.failed(stall, httpStatusCode: nil))
|
|
264
|
-
#expect(c.retry.attempts == 0)
|
|
265
267
|
c.play()
|
|
266
268
|
eh.resolveAndLoadCalls.removeAll()
|
|
267
269
|
|
|
@@ -394,7 +396,7 @@ struct RetryingErrorTests {
|
|
|
394
396
|
@MainActor
|
|
395
397
|
private func makePlayingWithRetries() throws -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
|
|
396
398
|
let engine = MockPlayerEngine()
|
|
397
|
-
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05)
|
|
399
|
+
let player = makePlayer(engine: engine, retry: makeRetryLoop(delay: 0.05))
|
|
398
400
|
let callbacks = MockPlayerCallbacks()
|
|
399
401
|
player.callbacks = callbacks
|
|
400
402
|
try startPlaying(player, engine)
|
|
@@ -963,69 +965,6 @@ struct NaturalEndPlayIntentTests {
|
|
|
963
965
|
}
|
|
964
966
|
}
|
|
965
967
|
|
|
966
|
-
// MARK: - Healthy playback refills the retry budget
|
|
967
|
-
|
|
968
|
-
/// Sustained playback proves the stream recovered, so the retry budget refills (as on
|
|
969
|
-
/// Android); otherwise a long-lived stream loses retry after its first recovered blip.
|
|
970
|
-
@Suite("Player - healthy playback resets retry budget")
|
|
971
|
-
struct HealthyPlaybackRetryResetTests {
|
|
972
|
-
/// A nonzero delay skips the retry, leaving the caller to start one that stays pending.
|
|
973
|
-
@MainActor
|
|
974
|
-
private func makeAfterOneRetry(delay: TimeInterval = 0) async -> (Player, RetryLoop, MockPlayerEngine) {
|
|
975
|
-
let retry = makeRetryLoop(delay: delay)
|
|
976
|
-
let engine = MockPlayerEngine()
|
|
977
|
-
let player = makePlayer(engine: engine, retry: retry)
|
|
978
|
-
if delay == 0 {
|
|
979
|
-
retry.handleError(URLError(.timedOut), context: .playback)
|
|
980
|
-
await retry.pendingTask?.value
|
|
981
|
-
}
|
|
982
|
-
return (player, retry, engine)
|
|
983
|
-
}
|
|
984
|
-
|
|
985
|
-
@Test @MainActor
|
|
986
|
-
func sustainedPlayback_resetsRetryBudget() async {
|
|
987
|
-
let (player, retry, _) = await makeAfterOneRetry()
|
|
988
|
-
#expect(retry.attempts == 1)
|
|
989
|
-
retry.healthyPlaybackDuration = .milliseconds(10)
|
|
990
|
-
|
|
991
|
-
player.transition(.avPlayerPlaying)
|
|
992
|
-
await retry.healthyPlaybackTask?.value
|
|
993
|
-
|
|
994
|
-
#expect(retry.attempts == 0)
|
|
995
|
-
}
|
|
996
|
-
|
|
997
|
-
/// reset() cancels a pending retry: a refill now would silently kill an in-flight reconnect.
|
|
998
|
-
@Test @MainActor
|
|
999
|
-
func refill_skipsWhileRetryIsPending() async {
|
|
1000
|
-
let (player, retry, _) = await makeAfterOneRetry(delay: 1)
|
|
1001
|
-
retry.healthyPlaybackDuration = .milliseconds(10)
|
|
1002
|
-
|
|
1003
|
-
player.transition(.avPlayerPlaying)
|
|
1004
|
-
retry.handleError(URLError(.timedOut), context: .playback)
|
|
1005
|
-
await retry.healthyPlaybackTask?.value
|
|
1006
|
-
|
|
1007
|
-
#expect(retry.pendingTask != nil)
|
|
1008
|
-
retry.cancel()
|
|
1009
|
-
}
|
|
1010
|
-
|
|
1011
|
-
@Test @MainActor
|
|
1012
|
-
func playbackInterruptedBeforeThreshold_doesNotReset() async {
|
|
1013
|
-
let (player, retry, engine) = await makeAfterOneRetry()
|
|
1014
|
-
engine.hasLoadedAsset = true
|
|
1015
|
-
retry.healthyPlaybackDuration = .milliseconds(500)
|
|
1016
|
-
|
|
1017
|
-
player.transition(.avPlayerPlaying)
|
|
1018
|
-
let refill = retry.healthyPlaybackTask
|
|
1019
|
-
player.transition(.avPlayerWaiting)
|
|
1020
|
-
|
|
1021
|
-
// Leaving .playing cancels the refill; awaiting the cancelled task reaches, deterministically,
|
|
1022
|
-
// the point where it would have fired.
|
|
1023
|
-
await refill?.value
|
|
1024
|
-
|
|
1025
|
-
#expect(retry.attempts == 1)
|
|
1026
|
-
}
|
|
1027
|
-
}
|
|
1028
|
-
|
|
1029
968
|
// MARK: - Sleep Timer Fade
|
|
1030
969
|
|
|
1031
970
|
@Suite("Player - sleep timer fade")
|
|
@@ -1373,27 +1312,13 @@ struct LoadTests {
|
|
|
1373
1312
|
let (c, eh, _, _) = makeCoordinator()
|
|
1374
1313
|
try c.setQueue([track("a"), track("b")])
|
|
1375
1314
|
let first = c.load
|
|
1376
|
-
|
|
1377
|
-
#expect(c.
|
|
1315
|
+
c.transition(.avPlayerPlaying)
|
|
1316
|
+
#expect(c.retry.hasPlayed)
|
|
1378
1317
|
|
|
1379
1318
|
c.next()
|
|
1380
1319
|
|
|
1381
1320
|
#expect(c.load != nil && c.load?.id != first?.id)
|
|
1382
|
-
#expect(c.
|
|
1383
|
-
}
|
|
1384
|
-
|
|
1385
|
-
/// The healthy-playback refill resets the retry budget mid-play; the load must survive it.
|
|
1386
|
-
@Test @MainActor
|
|
1387
|
-
func aRetryResetKeepsTheLoad() throws {
|
|
1388
|
-
let (c, eh, _, _) = makeCoordinator()
|
|
1389
|
-
try c.setQueue([track("a")])
|
|
1390
|
-
eh.emit(.audioDidStart)
|
|
1391
|
-
let load = c.load
|
|
1392
|
-
|
|
1393
|
-
c.retry.reset()
|
|
1394
|
-
|
|
1395
|
-
#expect(c.load == load)
|
|
1396
|
-
#expect(c.load?.hasPlayed == true)
|
|
1321
|
+
#expect(!c.retry.hasPlayed)
|
|
1397
1322
|
}
|
|
1398
1323
|
|
|
1399
1324
|
@Test
|
|
@@ -1462,6 +1387,7 @@ struct StopCancelsRetryTests {
|
|
|
1462
1387
|
let errorHandler = makeRetryLoop(delay: 0.05)
|
|
1463
1388
|
let engine = MockPlayerEngine()
|
|
1464
1389
|
let player = makePlayer(engine: engine, retry: errorHandler)
|
|
1390
|
+
errorHandler.playIntentChanged(true)
|
|
1465
1391
|
let callbacks = MockPlayerCallbacks()
|
|
1466
1392
|
player.callbacks = callbacks
|
|
1467
1393
|
|