react-native-audio-browser 0.2.0-next.61 → 0.2.0-next.62
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.
|
@@ -50,7 +50,10 @@ struct DeferredSeek {
|
|
|
50
50
|
return time
|
|
51
51
|
}
|
|
52
52
|
|
|
53
|
-
|
|
53
|
+
/// A seek cut short, as when its item fails, keeps the target for the reload; a seek that cut it
|
|
54
|
+
/// short lands in its place.
|
|
55
|
+
mutating func land(finished: Bool) -> Landing {
|
|
56
|
+
guard finished else { return .none }
|
|
54
57
|
switch state {
|
|
55
58
|
case .inFlight:
|
|
56
59
|
state = .idle
|
package/ios/Player/Player.swift
CHANGED
|
@@ -384,6 +384,7 @@ final class Player {
|
|
|
384
384
|
shouldResumeAfterInterruption = false
|
|
385
385
|
transition(.stopped)
|
|
386
386
|
setPlayWhenReady(false)
|
|
387
|
+
deferredSeek.reset()
|
|
387
388
|
if currentTrack?.live != true { seek(to: 0) }
|
|
388
389
|
}
|
|
389
390
|
|
|
@@ -665,7 +666,7 @@ final class Player {
|
|
|
665
666
|
func seekToLiveEdge() {
|
|
666
667
|
guard currentTrack?.live == true, engine.hasItem else { return }
|
|
667
668
|
if let edge = engine.liveEdge {
|
|
668
|
-
|
|
669
|
+
seek(to: edge)
|
|
669
670
|
} else {
|
|
670
671
|
reloadResolving(startFromCurrentTime: false)
|
|
671
672
|
}
|
|
@@ -680,7 +681,7 @@ final class Player {
|
|
|
680
681
|
completion(false)
|
|
681
682
|
return
|
|
682
683
|
}
|
|
683
|
-
seekDidLand()
|
|
684
|
+
seekDidLand(finished: finished)
|
|
684
685
|
completion(finished)
|
|
685
686
|
}
|
|
686
687
|
}
|
|
@@ -692,8 +693,8 @@ final class Player {
|
|
|
692
693
|
return true
|
|
693
694
|
}
|
|
694
695
|
|
|
695
|
-
private func seekDidLand() {
|
|
696
|
-
switch deferredSeek.land() {
|
|
696
|
+
private func seekDidLand(finished: Bool) {
|
|
697
|
+
switch deferredSeek.land(finished: finished) {
|
|
697
698
|
case .done:
|
|
698
699
|
if state == .loading { transition(.loadSeekCompleted) }
|
|
699
700
|
case let .reseek(time):
|
|
@@ -719,10 +720,12 @@ final class Player {
|
|
|
719
720
|
}
|
|
720
721
|
|
|
721
722
|
/// A restart from a terminal error begins a new Load on a new AVPlayer; automatic retries
|
|
722
|
-
/// never get here in .error, since the retry loop keeps the state non-terminal. `time
|
|
723
|
-
/// as the deferred seek before the loading transition saves the snapshot.
|
|
723
|
+
/// never get here in .error, since the retry loop keeps the state non-terminal. `time`, else the
|
|
724
|
+
/// pending target, is held as the deferred seek before the loading transition saves the snapshot.
|
|
724
725
|
private func prepareForReload(resumingAt time: TimeInterval?) {
|
|
725
726
|
load?.reloadOnPlay = false
|
|
727
|
+
let target = time ?? deferredSeek.target
|
|
728
|
+
deferredSeek.reset()
|
|
726
729
|
if state == .error {
|
|
727
730
|
beginLoad()
|
|
728
731
|
clearItem()
|
|
@@ -732,7 +735,7 @@ final class Player {
|
|
|
732
735
|
engine.dropAsset()
|
|
733
736
|
engine.pause()
|
|
734
737
|
}
|
|
735
|
-
if let
|
|
738
|
+
if let target { deferredSeek.capture(target) }
|
|
736
739
|
transition(.trackLoading)
|
|
737
740
|
}
|
|
738
741
|
|
|
@@ -18,7 +18,7 @@ struct DeferredSeekTests {
|
|
|
18
18
|
#expect(seek.begin() == 30)
|
|
19
19
|
#expect(seek.state == .inFlight(30))
|
|
20
20
|
#expect(seek.defersReady)
|
|
21
|
-
#expect(seek.land() == .done)
|
|
21
|
+
#expect(seek.land(finished: true) == .done)
|
|
22
22
|
#expect(seek.state == .idle)
|
|
23
23
|
#expect(!seek.defersReady)
|
|
24
24
|
}
|
|
@@ -45,15 +45,23 @@ struct DeferredSeekTests {
|
|
|
45
45
|
_ = seek.begin()
|
|
46
46
|
seek.capture(50)
|
|
47
47
|
#expect(seek.state == .pending(50))
|
|
48
|
-
#expect(seek.land() == .reseek(50))
|
|
48
|
+
#expect(seek.land(finished: true) == .reseek(50))
|
|
49
49
|
#expect(seek.state == .inFlight(50))
|
|
50
|
-
#expect(seek.land() == .done)
|
|
50
|
+
#expect(seek.land(finished: true) == .done)
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
@Test func anUnfinishedLandingKeepsTheTarget() {
|
|
54
|
+
var seek = DeferredSeek()
|
|
55
|
+
seek.capture(30)
|
|
56
|
+
_ = seek.begin()
|
|
57
|
+
#expect(seek.land(finished: false) == .none)
|
|
58
|
+
#expect(seek.state == .inFlight(30))
|
|
51
59
|
}
|
|
52
60
|
|
|
53
61
|
/// A seek issued while playing is never deferred, so its landing has nothing to do.
|
|
54
62
|
@Test func aLandingWithNothingInFlightIsNone() {
|
|
55
63
|
var seek = DeferredSeek()
|
|
56
|
-
#expect(seek.land() == .none)
|
|
64
|
+
#expect(seek.land(finished: true) == .none)
|
|
57
65
|
}
|
|
58
66
|
|
|
59
67
|
@Test func resetDropsTheTargetAndInvalidatesSeeksInFlight() {
|
|
@@ -74,6 +74,92 @@ struct PlayerSeekingTests {
|
|
|
74
74
|
#expect(player.state == .loading)
|
|
75
75
|
}
|
|
76
76
|
|
|
77
|
+
@Test func aCompletionFromBeforeAReloadIsDropped() throws {
|
|
78
|
+
let engine = MockPlayerEngine()
|
|
79
|
+
let player = makePlayer(engine: engine, retries: false)
|
|
80
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
81
|
+
engine.seekResult = nil
|
|
82
|
+
engine.hasItem = true
|
|
83
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
84
|
+
|
|
85
|
+
player.reloadResolving(startFromCurrentTime: true)
|
|
86
|
+
engine.completeSeeks(true)
|
|
87
|
+
engine.completeSeeks(true)
|
|
88
|
+
|
|
89
|
+
#expect(player.state == .loading)
|
|
90
|
+
#expect(player.deferredSeek.target == 25)
|
|
91
|
+
#expect(engine.seekCalls == [25])
|
|
92
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
93
|
+
#expect(engine.seekCalls == [25, 25])
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
@Test func aStartSeekCutShortWaitsForTheNextItem() throws {
|
|
97
|
+
let engine = MockPlayerEngine()
|
|
98
|
+
let player = makePlayer(engine: engine, retries: false)
|
|
99
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
100
|
+
engine.seekResult = nil
|
|
101
|
+
engine.hasItem = true
|
|
102
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
103
|
+
|
|
104
|
+
engine.completeSeeks(false)
|
|
105
|
+
|
|
106
|
+
#expect(player.state == .loading)
|
|
107
|
+
#expect(player.deferredSeek.target == 25)
|
|
108
|
+
#expect(engine.seekCalls == [25])
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
/// A media-load retry passes no position, so the start in flight is what it resumes from.
|
|
112
|
+
@Test func aReloadThatDoesNotResumeKeepsTheStartInFlight() throws {
|
|
113
|
+
let engine = MockPlayerEngine()
|
|
114
|
+
let player = makePlayer(engine: engine, retries: false)
|
|
115
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
116
|
+
engine.seekResult = nil
|
|
117
|
+
engine.hasItem = true
|
|
118
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
119
|
+
|
|
120
|
+
player.reloadResolving(startFromCurrentTime: false)
|
|
121
|
+
engine.completeSeeks(true)
|
|
122
|
+
|
|
123
|
+
#expect(player.state == .loading)
|
|
124
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
125
|
+
#expect(engine.seekCalls == [25, 25])
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
@Test func aPlayRightAfterAStopDuringTheStartSeekStartsOver() throws {
|
|
129
|
+
let engine = MockPlayerEngine()
|
|
130
|
+
let player = makePlayer(engine: engine, retries: false)
|
|
131
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "T")], startPositionMs: 25000)
|
|
132
|
+
engine.seekResult = nil
|
|
133
|
+
engine.hasItem = true
|
|
134
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
135
|
+
|
|
136
|
+
player.stop()
|
|
137
|
+
player.play()
|
|
138
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
139
|
+
|
|
140
|
+
#expect(engine.seekCalls == [25, 0])
|
|
141
|
+
#expect(player.deferredSeek.target == nil)
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
@Test func theLiveEdgeDuringALoadWaitsForTheStartSeek() throws {
|
|
145
|
+
let engine = MockPlayerEngine()
|
|
146
|
+
let player = makePlayer(engine: engine, retries: false)
|
|
147
|
+
try player.setQueue([Track(id: "t1", src: "https://example.com/a.m3u8", title: "T", live: true)], startPositionMs: 25000)
|
|
148
|
+
engine.seekResult = nil
|
|
149
|
+
engine.hasItem = true
|
|
150
|
+
engine.hasLoadedAsset = true
|
|
151
|
+
engine.liveEdge = 120
|
|
152
|
+
engine.emit(.itemPrepared(likelyToKeepUp: true))
|
|
153
|
+
|
|
154
|
+
player.seekToLiveEdge()
|
|
155
|
+
#expect(engine.seekCalls == [25])
|
|
156
|
+
engine.completeSeeks(true)
|
|
157
|
+
engine.completeSeeks(true)
|
|
158
|
+
|
|
159
|
+
#expect(engine.seekCalls == [25, 120])
|
|
160
|
+
#expect(player.state != .loading)
|
|
161
|
+
}
|
|
162
|
+
|
|
77
163
|
@Test func theLiveEdgeIsTheSeekableWindowsEnd_orAReconnectWithoutOne() throws {
|
|
78
164
|
let (player, engine, _) = try makePlaying(live: true)
|
|
79
165
|
engine.liveEdge = 120
|