mirror/advplyr.audiobookshelf-app
1
0
Fork 0
mirror of https://github.com/advplyr/audiobookshelf-app.git synced 2025-08-20 09:40:17 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove DispatchQueue as that did not fix Realm crashes

Browse source
This commit is contained in:
ronaldheft 2022-08-24 19:57:39 -04:00
parent b5e33b1707
commit 01678f2c91
2 changed files with 72 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ios/App/Shared/player/AudioPlayer.swift
View file

@ -18,6 +18,8 @@ enum PlayMethod:Int {
} }
class AudioPlayer: NSObject { class AudioPlayer: NSObject {
private let queue = DispatchQueue(label: "ABSAudioPlayerQueue")
// enums and @objc are not compatible // enums and @objc are not compatible
@objc dynamic var status: Int @objc dynamic var status: Int
@objc dynamic var rate: Float @objc dynamic var rate: Float
@ -141,7 +143,7 @@ class AudioPlayer: NSObject {
// Rate will be different depending on playback speed, aim for 2 observations/sec // Rate will be different depending on playback speed, aim for 2 observations/sec
let seconds = 0.5 * (self.rate > 0 ? self.rate : 1.0) let seconds = 0.5 * (self.rate > 0 ? self.rate : 1.0)
let time = CMTime(seconds: Double(seconds), preferredTimescale: timeScale) let time = CMTime(seconds: Double(seconds), preferredTimescale: timeScale)
self.timeObserverToken = self.audioPlayer.addPeriodicTimeObserver(forInterval: time, queue: PlayerProgress.queue) { [weak self] time in self.timeObserverToken = self.audioPlayer.addPeriodicTimeObserver(forInterval: time, queue: queue) { [weak self] time in
let sleepTimeStopAt = self?.sleepTimeStopAt let sleepTimeStopAt = self?.sleepTimeStopAt
Task { Task {
// Let the player update the current playback positions // Let the player update the current playback positions
@ -205,7 +207,7 @@ class AudioPlayer: NSObject {
private func startPausedTimer() { private func startPausedTimer() {
guard self.pausedTimer == nil else { return } guard self.pausedTimer == nil else { return }
PlayerProgress.queue.async { self.queue.async {
self.pausedTimer = Timer.scheduledTimer(withTimeInterval: 10, repeats: true) { timer in self.pausedTimer = Timer.scheduledTimer(withTimeInterval: 10, repeats: true) { timer in
NSLog("PAUSE TIMER: Syncing from server") NSLog("PAUSE TIMER: Syncing from server")
Task { await PlayerProgress.shared.syncFromServer() } Task { await PlayerProgress.shared.syncFromServer() }
@ -398,7 +400,7 @@ class AudioPlayer: NSObject {
var times = [NSValue]() var times = [NSValue]()
times.append(NSValue(time: sleepTime)) times.append(NSValue(time: sleepTime))
sleepTimeToken = self.audioPlayer.addBoundaryTimeObserver(forTimes: times, queue: PlayerProgress.queue) { [weak self] in sleepTimeToken = self.audioPlayer.addBoundaryTimeObserver(forTimes: times, queue: queue) { [weak self] in
NSLog("SLEEP TIMER: Pausing audio") NSLog("SLEEP TIMER: Pausing audio")
self?.pause() self?.pause()
self?.removeSleepTimer() self?.removeSleepTimer()

144
ios/App/Shared/player/PlayerProgress.swift
View file

@ -11,7 +11,6 @@ import RealmSwift
class PlayerProgress { class PlayerProgress {
public static let shared = PlayerProgress() public static let shared = PlayerProgress()
public static let queue = DispatchQueue(label: "ABSPlayerProgressQueue")
private static let TIME_BETWEEN_SESSION_SYNC_IN_SECONDS = 10.0 private static let TIME_BETWEEN_SESSION_SYNC_IN_SECONDS = 10.0
@ -46,50 +45,46 @@ class PlayerProgress {
// MARK: - SYNC LOGIC // MARK: - SYNC LOGIC
private func updateLocalSessionFromPlayer(currentTime: Double, includesPlayProgress: Bool) -> PlaybackSession? { private func updateLocalSessionFromPlayer(currentTime: Double, includesPlayProgress: Bool) -> PlaybackSession? {
PlayerProgress.queue.sync { guard let session = PlayerHandler.getPlaybackSession() else { return nil }
guard let session = PlayerHandler.getPlaybackSession() else { return nil } guard !currentTime.isNaN else { return nil } // Prevent bad data on player stop
guard !currentTime.isNaN else { return nil } // Prevent bad data on player stop
session.update {
session.realm?.refresh()
session.update { let nowInSeconds = Date().timeIntervalSince1970
session.realm?.refresh() let nowInMilliseconds = nowInSeconds * 1000
let lastUpdateInMilliseconds = session.updatedAt ?? nowInMilliseconds
let nowInSeconds = Date().timeIntervalSince1970 let lastUpdateInSeconds = lastUpdateInMilliseconds / 1000
let nowInMilliseconds = nowInSeconds * 1000 let secondsSinceLastUpdate = nowInSeconds - lastUpdateInSeconds
let lastUpdateInMilliseconds = session.updatedAt ?? nowInMilliseconds
let lastUpdateInSeconds = lastUpdateInMilliseconds / 1000 session.currentTime = currentTime
let secondsSinceLastUpdate = nowInSeconds - lastUpdateInSeconds session.updatedAt = nowInMilliseconds
session.currentTime = currentTime if includesPlayProgress {
session.updatedAt = nowInMilliseconds session.timeListening += secondsSinceLastUpdate
if includesPlayProgress {
session.timeListening += secondsSinceLastUpdate
}
} }
return session.freeze()
} }
return session.freeze()
} }
private func updateLocalMediaProgressFromLocalSession() { private func updateLocalMediaProgressFromLocalSession() {
PlayerProgress.queue.sync { guard let session = PlayerHandler.getPlaybackSession() else { return }
guard let session = PlayerHandler.getPlaybackSession() else { return } guard session.isLocal else { return }
guard session.isLocal else { return }
let localMediaProgress = LocalMediaProgress.fetchOrCreateLocalMediaProgress(localMediaProgressId: session.localMediaProgressId, localLibraryItemId: session.localLibraryItem?.id, localEpisodeId: session.episodeId)
let localMediaProgress = LocalMediaProgress.fetchOrCreateLocalMediaProgress(localMediaProgressId: session.localMediaProgressId, localLibraryItemId: session.localLibraryItem?.id, localEpisodeId: session.episodeId) guard let localMediaProgress = localMediaProgress else {
guard let localMediaProgress = localMediaProgress else { // Local media progress should have been created
// Local media progress should have been created // If we're here, it means a library id is invalid
// If we're here, it means a library id is invalid return
return
}
localMediaProgress.updateFromPlaybackSession(session)
NSLog("Local progress saved to the database")
// Send the local progress back to front-end
NotificationCenter.default.post(name: NSNotification.Name(PlayerEvents.localProgress.rawValue), object: nil)
} }
localMediaProgress.updateFromPlaybackSession(session)
NSLog("Local progress saved to the database")
// Send the local progress back to front-end
NotificationCenter.default.post(name: NSNotification.Name(PlayerEvents.localProgress.rawValue), object: nil)
} }
private func updateAllServerSessionFromLocalSession() async { private func updateAllServerSessionFromLocalSession() async {
@ -105,33 +100,32 @@ class PlayerProgress {
} }
private func updateServerSessionFromLocalSession(_ session: PlaybackSession, rateLimitSync: Bool = false) async { private func updateServerSessionFromLocalSession(_ session: PlaybackSession, rateLimitSync: Bool = false) async {
PlayerProgress.queue.sync { var safeToSync = true
var safeToSync = true
guard var session = session.thaw() else { return }
// We need to update and check the server time in a transaction for thread-safety
session.update {
session.realm?.refresh()
let nowInMilliseconds = Date().timeIntervalSince1970 * 1000
let lastUpdateInMilliseconds = session.serverUpdatedAt
// If required, rate limit requests based on session last update
if rateLimitSync {
let timeSinceLastSync = nowInMilliseconds - lastUpdateInMilliseconds
let timeBetweenSessionSync = PlayerProgress.TIME_BETWEEN_SESSION_SYNC_IN_SECONDS * 1000
safeToSync = timeSinceLastSync > timeBetweenSessionSync
if !safeToSync {
return // This only exits the update block
}
}
session.serverUpdatedAt = nowInMilliseconds
}
session = session.freeze()
guard safeToSync else { return }
}
guard var session = session.thaw() else { return }
// We need to update and check the server time in a transaction for thread-safety
session.update {
session.realm?.refresh()
let nowInMilliseconds = Date().timeIntervalSince1970 * 1000
let lastUpdateInMilliseconds = session.serverUpdatedAt
// If required, rate limit requests based on session last update
if rateLimitSync {
let timeSinceLastSync = nowInMilliseconds - lastUpdateInMilliseconds
let timeBetweenSessionSync = PlayerProgress.TIME_BETWEEN_SESSION_SYNC_IN_SECONDS * 1000
safeToSync = timeSinceLastSync > timeBetweenSessionSync
if !safeToSync {
return // This only exits the update block
}
}
session.serverUpdatedAt = nowInMilliseconds
}
session = session.freeze()
guard safeToSync else { return }
NSLog("Sending sessionId(\(session.id)) to server") NSLog("Sending sessionId(\(session.id)) to server")
var success = false var success = false
@ -145,10 +139,8 @@ class PlayerProgress {
// Remove old sessions after they synced with the server // Remove old sessions after they synced with the server
if success && !session.isActiveSession { if success && !session.isActiveSession {
PlayerProgress.queue.sync { if let session = session.thaw() {
if let session = session.thaw() { session.delete()
session.delete()
}
} }
} }
} }
@ -183,16 +175,14 @@ class PlayerProgress {
// Update the session, if needed // Update the session, if needed
if serverIsNewerThanLocal && currentTimeIsDifferent { if serverIsNewerThanLocal && currentTimeIsDifferent {
PlayerProgress.queue.sync { NSLog("updateLocalSessionFromServerMediaProgress: Server has newer time than local serverLastUpdate=\(serverLastUpdate) localLastUpdate=\(localLastUpdate)")
NSLog("updateLocalSessionFromServerMediaProgress: Server has newer time than local serverLastUpdate=\(serverLastUpdate) localLastUpdate=\(localLastUpdate)") guard let session = session.thaw() else { return }
guard let session = session.thaw() else { return } session.update {
session.update { session.currentTime = serverCurrentTime
session.currentTime = serverCurrentTime session.updatedAt = serverLastUpdate
session.updatedAt = serverLastUpdate
}
NSLog("updateLocalSessionFromServerMediaProgress: Updated session currentTime newCurrentTime=\(serverCurrentTime) previousCurrentTime=\(localCurrentTime)")
PlayerHandler.seek(amount: session.currentTime)
} }
NSLog("updateLocalSessionFromServerMediaProgress: Updated session currentTime newCurrentTime=\(serverCurrentTime) previousCurrentTime=\(localCurrentTime)")
PlayerHandler.seek(amount: session.currentTime)
} else { } else {
NSLog("updateLocalSessionFromServerMediaProgress: Local session does not need updating; local has latest progress") NSLog("updateLocalSessionFromServerMediaProgress: Local session does not need updating; local has latest progress")
} }