starred/audiobookshelf-app
1
0
Fork 0
mirror of https://github.com/advplyr/audiobookshelf-app.git synced 2026-08-29 22:57:16 +02:00
Code Issues 454 Packages Projects Releases 10 Wiki Activity

Merge pull request #1937 from nichwall/download-overhaul-again

Browse Source 
Android download rewrite, try 2
This commit is contained in:
advplyr
2026-07-30 18:36:32 -04:00
committed by GitHub
parent 185cba16eb e5ef38295d
commit 425ef4c3b6
25 changed files with 1614 additions and 1267 deletions
Download Patch File Download Diff File Expand all files Collapse all files
android/app/build.gradle
+1
View File
@@ -92,6 +92,7 @@ dependencies {
implementation project(':capacitor-cordova-android-plugins') implementation project(':capacitor-cordova-android-plugins')
implementation "androidx.core:core-ktx:$androidx_core_ktx_version" implementation "androidx.core:core-ktx:$androidx_core_ktx_version"
implementation "androidx.work:work-runtime-ktx:2.9.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version"
android/app/src/main/AndroidManifest.xml
+8
View File
@@ -6,12 +6,14 @@
<!-- Permissions --> <!-- Permissions -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" /> <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" /> <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.INTERNET" />
<uses-permission <uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:name="android.permission.WRITE_EXTERNAL_STORAGE"
android:maxSdkVersion="28" /> android:maxSdkVersion="28" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<application <application
android:allowBackup="true" android:allowBackup="true"
@@ -98,6 +100,12 @@
</intent-filter> </intent-filter>
</service> </service>
<service
android:name=".services.DownloadService"
android:enabled="true"
android:exported="false"
android:foregroundServiceType="dataSync" />
<provider <provider
android:name="androidx.core.content.FileProvider" android:name="androidx.core.content.FileProvider"
android:authorities="${applicationId}.fileprovider" android:authorities="${applicationId}.fileprovider"
android/app/src/main/java/com/audiobookshelf/app/MainActivity.kt
+14 -8
View File
@@ -40,9 +40,6 @@ class MainActivity : BridgeActivity() {
val storage = SimpleStorage(this) val storage = SimpleStorage(this)
val REQUEST_PERMISSIONS = 1 val REQUEST_PERMISSIONS = 1
var PERMISSIONS_ALL = arrayOf(
Manifest.permission.READ_EXTERNAL_STORAGE
)
public override fun onCreate(savedInstanceState: Bundle?) { public override fun onCreate(savedInstanceState: Bundle?) {
DbManager.initialize(applicationContext) DbManager.initialize(applicationContext)
@@ -98,11 +95,20 @@ class MainActivity : BridgeActivity() {
} }
} }
val permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) requestNeededPermissions()
if (permission != PackageManager.PERMISSION_GRANTED) { }
ActivityCompat.requestPermissions(this,
PERMISSIONS_ALL, private fun requestNeededPermissions() {
REQUEST_PERMISSIONS) val needed = mutableListOf<String>()
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
needed.add(Manifest.permission.READ_EXTERNAL_STORAGE)
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
ActivityCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
needed.add(Manifest.permission.POST_NOTIFICATIONS)
}
if (needed.isNotEmpty()) {
ActivityCompat.requestPermissions(this, needed.toTypedArray(), REQUEST_PERMISSIONS)
} }
} }
android/app/src/main/java/com/audiobookshelf/app/data/DeviceClasses.kt
+146 -113
View File
@@ -1,74 +1,102 @@
package com.audiobookshelf.app.data package com.audiobookshelf.app.data
import android.content.Context import android.content.Context
import android.net.Uri
import android.support.v4.media.MediaDescriptionCompat import android.support.v4.media.MediaDescriptionCompat
import android.util.Log import android.util.Log
import com.fasterxml.jackson.annotation.JsonIgnore import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonIgnoreProperties
import com.fasterxml.jackson.annotation.JsonSubTypes import com.fasterxml.jackson.annotation.JsonSubTypes
import com.fasterxml.jackson.annotation.JsonTypeInfo import com.fasterxml.jackson.annotation.JsonTypeInfo
import java.io.File
enum class LockOrientationSetting { enum class LockOrientationSetting {
NONE, PORTRAIT, LANDSCAPE NONE,
PORTRAIT,
LANDSCAPE
} }
enum class HapticFeedbackSetting { enum class HapticFeedbackSetting {
OFF, LIGHT, MEDIUM, HEAVY OFF,
LIGHT,
MEDIUM,
HEAVY
} }
enum class ShakeSensitivitySetting { enum class ShakeSensitivitySetting {
VERY_LOW, LOW, MEDIUM, HIGH, VERY_HIGH VERY_LOW,
LOW,
MEDIUM,
HIGH,
VERY_HIGH
} }
enum class DownloadUsingCellularSetting { enum class DownloadUsingCellularSetting {
ASK, ALWAYS, NEVER ASK,
ALWAYS,
NEVER
} }
enum class StreamingUsingCellularSetting { enum class StreamingUsingCellularSetting {
ASK, ALWAYS, NEVER ASK,
ALWAYS,
NEVER
} }
enum class AndroidAutoBrowseSeriesSequenceOrderSetting { enum class AndroidAutoBrowseSeriesSequenceOrderSetting {
ASC, DESC ASC,
DESC
} }
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class ServerConnectionConfig( data class ServerConnectionConfig(
var id:String, var id: String,
var index:Int, var index: Int,
var name:String, var name: String,
var address:String, var address: String,
// version added after 0.9.81-beta // version added after 0.9.81-beta
var version:String?, var version: String?,
var userId:String, var userId: String,
var username:String, var username: String,
var token:String, var token: String,
var customHeaders:Map<String, String>? var customHeaders: Map<String, String>?
) )
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class LocalFile( data class LocalFile(
var id:String, var id: String,
var filename:String?, var filename: String?,
var contentUrl:String, var contentUrl: String,
var basePath:String, var basePath: String,
var absolutePath:String, var absolutePath: String,
var simplePath:String, var mimeType: String?,
var mimeType:String?, var size: Long
var size:Long
) { ) {
@JsonIgnore @JsonIgnore
fun isAudioFile():Boolean { fun exists(ctx: Context): Boolean {
if (contentUrl.startsWith("content:")) {
return try {
ctx.contentResolver.openFileDescriptor(Uri.parse(contentUrl), "r")?.use { true } ?: false
} catch (e: Exception) {
Log.w("LocalFile", "Cannot access SAF file $contentUrl", e)
false
}
}
return File(absolutePath).exists()
}
@JsonIgnore
fun isAudioFile(): Boolean {
if (mimeType == "application/octet-stream") return true if (mimeType == "application/octet-stream") return true
if (mimeType == "video/mp4") return true if (mimeType == "video/mp4") return true
return mimeType?.startsWith("audio") == true return mimeType?.startsWith("audio") == true
} }
@JsonIgnore @JsonIgnore
fun isEBookFile():Boolean { fun isEBookFile(): Boolean {
return getEBookFormat() != null return getEBookFormat() != null
} }
@JsonIgnore @JsonIgnore
fun getEBookFormat():String? { fun getEBookFormat(): String? {
if (mimeType == "application/epub+zip") return "epub" if (mimeType == "application/epub+zip") return "epub"
if (mimeType == "application/pdf") return "pdf" if (mimeType == "application/pdf") return "pdf"
if (mimeType == "application/x-mobipocket-ebook") return "mobi" if (mimeType == "application/x-mobipocket-ebook") return "mobi"
@@ -81,118 +109,124 @@ data class LocalFile(
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class LocalFolder( data class LocalFolder(
var id:String, var id: String,
var name:String, var name: String,
var contentUrl:String, var contentUrl: String,
var basePath:String, var basePath: String,
var absolutePath:String, var absolutePath: String,
var simplePath:String, var storageType: String,
var storageType:String, var mediaType: String
var mediaType:String
) )
@JsonTypeInfo(use= JsonTypeInfo.Id.DEDUCTION) @JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION)
@JsonSubTypes( @JsonSubTypes(JsonSubTypes.Type(LibraryItem::class), JsonSubTypes.Type(LocalLibraryItem::class))
JsonSubTypes.Type(LibraryItem::class), open class LibraryItemWrapper(var id: String) {
JsonSubTypes.Type(LocalLibraryItem::class)
)
open class LibraryItemWrapper(var id:String) {
@JsonIgnore @JsonIgnore
open fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat { return MediaDescriptionCompat.Builder().build() } open fun getMediaDescription(
progress: MediaProgressWrapper?,
ctx: Context
): MediaDescriptionCompat {
return MediaDescriptionCompat.Builder().build()
}
} }
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class DeviceInfo( data class DeviceInfo(
var deviceId:String, var deviceId: String,
var manufacturer:String, var manufacturer: String,
var model:String, var model: String,
var sdkVersion:Int, var sdkVersion: Int,
var clientVersion: String var clientVersion: String
) )
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class PlayItemRequestPayload( data class PlayItemRequestPayload(
var mediaPlayer:String, var mediaPlayer: String,
var forceDirectPlay:Boolean, var forceDirectPlay: Boolean,
var forceTranscode:Boolean, var forceTranscode: Boolean,
var deviceInfo:DeviceInfo var deviceInfo: DeviceInfo
) )
@JsonIgnoreProperties(ignoreUnknown = true) @JsonIgnoreProperties(ignoreUnknown = true)
data class DeviceSettings( data class DeviceSettings(
var disableAutoRewind:Boolean, var disableAutoRewind: Boolean,
var enableAltView:Boolean, var enableAltView: Boolean,
var allowSeekingOnMediaControls:Boolean, var allowSeekingOnMediaControls: Boolean,
var jumpBackwardsTime:Int, var jumpBackwardsTime: Int,
var jumpForwardTime:Int, var jumpForwardTime: Int,
var enableMp3IndexSeeking:Boolean, var enableMp3IndexSeeking: Boolean,
var disableShakeToResetSleepTimer:Boolean, var disableShakeToResetSleepTimer: Boolean,
var shakeSensitivity: ShakeSensitivitySetting, var shakeSensitivity: ShakeSensitivitySetting,
var lockOrientation: LockOrientationSetting, var lockOrientation: LockOrientationSetting,
var hapticFeedback: HapticFeedbackSetting, var hapticFeedback: HapticFeedbackSetting,
var autoSleepTimer: Boolean, var autoSleepTimer: Boolean,
var autoSleepTimerStartTime: String, var autoSleepTimerStartTime: String,
var autoSleepTimerEndTime: String, var autoSleepTimerEndTime: String,
var autoSleepTimerAutoRewind: Boolean, var autoSleepTimerAutoRewind: Boolean,
var autoSleepTimerAutoRewindTime: Long, //Time in milliseconds var autoSleepTimerAutoRewindTime: Long, // Time in milliseconds
var sleepTimerLength: Long, // Time in milliseconds var sleepTimerLength: Long, // Time in milliseconds
var disableSleepTimerFadeOut: Boolean, var disableSleepTimerFadeOut: Boolean,
var disableSleepTimerResetFeedback: Boolean, var disableSleepTimerResetFeedback: Boolean,
var enableSleepTimerAlmostDoneChime: Boolean, var enableSleepTimerAlmostDoneChime: Boolean,
var languageCode: String, var languageCode: String,
var downloadUsingCellular: DownloadUsingCellularSetting, var downloadUsingCellular: DownloadUsingCellularSetting,
var streamingUsingCellular: StreamingUsingCellularSetting, var streamingUsingCellular: StreamingUsingCellularSetting,
var androidAutoBrowseLimitForGrouping: Int, var androidAutoBrowseLimitForGrouping: Int,
var androidAutoBrowseSeriesSequenceOrder: AndroidAutoBrowseSeriesSequenceOrderSetting var androidAutoBrowseSeriesSequenceOrder: AndroidAutoBrowseSeriesSequenceOrderSetting
) { ) {
companion object { companion object {
// Static method to get default device settings // Static method to get default device settings
fun default():DeviceSettings { fun default(): DeviceSettings {
return DeviceSettings( return DeviceSettings(
disableAutoRewind = false, disableAutoRewind = false,
enableAltView = true, enableAltView = true,
allowSeekingOnMediaControls = false, allowSeekingOnMediaControls = false,
jumpBackwardsTime = 10, jumpBackwardsTime = 10,
jumpForwardTime = 10, jumpForwardTime = 10,
enableMp3IndexSeeking = false, enableMp3IndexSeeking = false,
disableShakeToResetSleepTimer = false, disableShakeToResetSleepTimer = false,
shakeSensitivity = ShakeSensitivitySetting.MEDIUM, shakeSensitivity = ShakeSensitivitySetting.MEDIUM,
lockOrientation = LockOrientationSetting.NONE, lockOrientation = LockOrientationSetting.NONE,
hapticFeedback = HapticFeedbackSetting.LIGHT, hapticFeedback = HapticFeedbackSetting.LIGHT,
autoSleepTimer = false, autoSleepTimer = false,
autoSleepTimerStartTime = "22:00", autoSleepTimerStartTime = "22:00",
autoSleepTimerEndTime = "06:00", autoSleepTimerEndTime = "06:00",
sleepTimerLength = 900000L, // 15 minutes sleepTimerLength = 900000L, // 15 minutes
autoSleepTimerAutoRewind = false, autoSleepTimerAutoRewind = false,
autoSleepTimerAutoRewindTime = 300000L, // 5 minutes autoSleepTimerAutoRewindTime = 300000L, // 5 minutes
disableSleepTimerFadeOut = false, disableSleepTimerFadeOut = false,
disableSleepTimerResetFeedback = false, disableSleepTimerResetFeedback = false,
enableSleepTimerAlmostDoneChime = false, enableSleepTimerAlmostDoneChime = false,
languageCode = "en-us", languageCode = "en-us",
downloadUsingCellular = DownloadUsingCellularSetting.ALWAYS, downloadUsingCellular = DownloadUsingCellularSetting.ALWAYS,
streamingUsingCellular = StreamingUsingCellularSetting.ALWAYS, streamingUsingCellular = StreamingUsingCellularSetting.ALWAYS,
androidAutoBrowseLimitForGrouping = 100, androidAutoBrowseLimitForGrouping = 100,
androidAutoBrowseSeriesSequenceOrder = AndroidAutoBrowseSeriesSequenceOrderSetting.ASC androidAutoBrowseSeriesSequenceOrder = AndroidAutoBrowseSeriesSequenceOrderSetting.ASC
) )
} }
} }
@get:JsonIgnore @get:JsonIgnore
val jumpBackwardsTimeMs get() = jumpBackwardsTime * 1000L val jumpBackwardsTimeMs
get() = jumpBackwardsTime * 1000L
@get:JsonIgnore @get:JsonIgnore
val jumpForwardTimeMs get() = jumpForwardTime * 1000L val jumpForwardTimeMs
get() = jumpForwardTime * 1000L
@get:JsonIgnore @get:JsonIgnore
val autoSleepTimerStartHour get() = autoSleepTimerStartTime.split(":")[0].toInt() val autoSleepTimerStartHour
get() = autoSleepTimerStartTime.split(":")[0].toInt()
@get:JsonIgnore @get:JsonIgnore
val autoSleepTimerStartMinute get() = autoSleepTimerStartTime.split(":")[1].toInt() val autoSleepTimerStartMinute
get() = autoSleepTimerStartTime.split(":")[1].toInt()
@get:JsonIgnore @get:JsonIgnore
val autoSleepTimerEndHour get() = autoSleepTimerEndTime.split(":")[0].toInt() val autoSleepTimerEndHour
get() = autoSleepTimerEndTime.split(":")[0].toInt()
@get:JsonIgnore @get:JsonIgnore
val autoSleepTimerEndMinute get() = autoSleepTimerEndTime.split(":")[1].toInt() val autoSleepTimerEndMinute
get() = autoSleepTimerEndTime.split(":")[1].toInt()
@JsonIgnore @JsonIgnore
fun getShakeThresholdGravity() : Float { // Used in ShakeDetector fun getShakeThresholdGravity(): Float { // Used in ShakeDetector
return if (shakeSensitivity == ShakeSensitivitySetting.VERY_HIGH) 1.1f return if (shakeSensitivity == ShakeSensitivitySetting.VERY_HIGH) 1.1f
else if (shakeSensitivity == ShakeSensitivitySetting.HIGH) 1.3f else if (shakeSensitivity == ShakeSensitivitySetting.HIGH) 1.3f
else if (shakeSensitivity == ShakeSensitivitySetting.MEDIUM) 1.5f else if (shakeSensitivity == ShakeSensitivitySetting.MEDIUM) 1.5f
@@ -206,10 +240,10 @@ data class DeviceSettings(
} }
data class DeviceData( data class DeviceData(
var serverConnectionConfigs:MutableList<ServerConnectionConfig>, var serverConnectionConfigs: MutableList<ServerConnectionConfig>,
var lastServerConnectionConfigId:String?, var lastServerConnectionConfigId: String?,
var deviceSettings: DeviceSettings?, var deviceSettings: DeviceSettings?,
var lastPlaybackSession: PlaybackSession? var lastPlaybackSession: PlaybackSession?
) { ) {
@JsonIgnore @JsonIgnore
fun getLastServerConnectionConfig(): ServerConnectionConfig? { fun getLastServerConnectionConfig(): ServerConnectionConfig? {
@@ -218,4 +252,3 @@ data class DeviceData(
} }
} }
} }
android/app/src/main/java/com/audiobookshelf/app/data/FolderScanResult.kt
-15
View File
@@ -1,15 +0,0 @@
package com.audiobookshelf.app.data
data class FolderScanResult(
var itemsAdded:Int,
var itemsUpdated:Int,
var itemsRemoved:Int,
var itemsUpToDate:Int,
val localFolder:LocalFolder,
val localLibraryItems:List<LocalLibraryItem>,
)
data class LocalLibraryItemScanResult(
val updated:Boolean,
val localLibraryItem:LocalLibraryItem,
)
android/app/src/main/java/com/audiobookshelf/app/data/LocalLibraryItem.kt
+7 -4
View File
@@ -80,7 +80,7 @@ class LocalLibraryItem(
} }
@JsonIgnore @JsonIgnore
fun hasTracks(episode:PodcastEpisode?): Boolean { fun hasTracks(ctx: Context, episode:PodcastEpisode?): Boolean {
var audioTracks = media.getAudioTracks() as MutableList<AudioTrack> var audioTracks = media.getAudioTracks() as MutableList<AudioTrack>
if (episode != null) { // Get podcast episode audio track if (episode != null) { // Get podcast episode audio track
episode.audioTrack?.let { at -> mutableListOf(at) }?.let { tracks -> audioTracks = tracks } episode.audioTrack?.let { at -> mutableListOf(at) }?.let { tracks -> audioTracks = tracks }
@@ -91,15 +91,18 @@ class LocalLibraryItem(
if (it.metadata === null) { if (it.metadata === null) {
return false return false
} }
// Check that file exists if (!trackExists(ctx, it.contentUrl, it.metadata!!.path)) {
val file = File(it.metadata!!.path)
if (!file.exists()) {
return false return false
} }
} }
return true return true
} }
@JsonIgnore
private fun trackExists(ctx: Context, contentUrl: String?, path: String): Boolean {
return LocalFile("", null, contentUrl ?: "", "", path, null, 0).exists(ctx)
}
@JsonIgnore @JsonIgnore
fun getPlaybackSession(episode:PodcastEpisode?, deviceInfo:DeviceInfo):PlaybackSession { fun getPlaybackSession(episode:PodcastEpisode?, deviceInfo:DeviceInfo):PlaybackSession {
val localEpisodeId = episode?.id val localEpisodeId = episode?.id
android/app/src/main/java/com/audiobookshelf/app/data/LocalMediaItem.kt
-1
View File
@@ -14,7 +14,6 @@ data class LocalMediaItem(
var mediaType: String, var mediaType: String,
var folderId: String, var folderId: String,
var contentUrl: String, var contentUrl: String,
var simplePath: String,
var basePath: String, var basePath: String,
var absolutePath: String, var absolutePath: String,
var audioTracks: MutableList<AudioTrack>, var audioTracks: MutableList<AudioTrack>,
android/app/src/main/java/com/audiobookshelf/app/device/FolderScanner.kt
+251 -515
View File
@@ -7,570 +7,306 @@ import androidx.documentfile.provider.DocumentFile
import com.anggrayudi.storage.file.* import com.anggrayudi.storage.file.*
import com.audiobookshelf.app.data.* import com.audiobookshelf.app.data.*
import com.audiobookshelf.app.models.DownloadItem import com.audiobookshelf.app.models.DownloadItem
import com.fasterxml.jackson.core.json.JsonReadFeature import com.audiobookshelf.app.models.DownloadItemPart
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import java.io.File import java.io.File
class FolderScanner(var ctx: Context) { /** Creates local-library records from a completed download manifest. */
class FolderScanner(private val ctx: Context) {
private val tag = "FolderScanner" private val tag = "FolderScanner"
private var jacksonMapper =
jacksonObjectMapper()
.enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
data class DownloadItemScanResult( data class DownloadItemScanResult(
val localLibraryItem: LocalLibraryItem, val localLibraryItem: LocalLibraryItem,
var localMediaProgress: LocalMediaProgress? var localMediaProgress: LocalMediaProgress?
) )
private fun getLocalLibraryItemId(mediaItemId: String): String { private fun localLibraryItemId(mediaItemId: String) =
return "local_" + DeviceManager.getBase64Id(mediaItemId) "local_${DeviceManager.getBase64Id(mediaItemId)}"
}
private fun scanInternalDownloadItem( private fun createLocalFile(
downloadItem: DownloadItem, part: DownloadItemPart,
cb: (DownloadItemScanResult?) -> Unit externalFile: DocumentFile? = null
) { ): LocalFile? {
val localLibraryItemId = "local_${downloadItem.libraryItemId}" if (part.isInternalStorage) {
val file = File(part.finalDestinationPath)
var localEpisodeId: String? = null if (!file.exists()) return null
var localLibraryItem: LocalLibraryItem? return LocalFile(
if (downloadItem.mediaType == "book") { DeviceManager.getBase64Id(file.name),
localLibraryItem = file.name,
LocalLibraryItem( Uri.fromFile(file).toString(),
localLibraryItemId, file.getBasePath(ctx),
downloadItem.localFolder.id, file.absolutePath,
downloadItem.itemFolderPath, file.mimeType,
downloadItem.itemFolderPath, file.length()
"", )
false,
downloadItem.mediaType,
downloadItem.media.getLocalCopy(),
mutableListOf(),
null,
null,
true,
downloadItem.serverConnectionConfigId,
downloadItem.serverAddress,
downloadItem.serverUserId,
downloadItem.libraryItemId
)
} else {
// Lookup or create podcast local library item
localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
if (localLibraryItem == null) {
Log.d(
tag,
"[FolderScanner] Podcast local library item not created yet for ${downloadItem.media.metadata.title}"
)
localLibraryItem =
LocalLibraryItem(
localLibraryItemId,
downloadItem.localFolder.id,
downloadItem.itemFolderPath,
downloadItem.itemFolderPath,
"",
false,
downloadItem.mediaType,
downloadItem.media.getLocalCopy(),
mutableListOf(),
null,
null,
true,
downloadItem.serverConnectionConfigId,
downloadItem.serverAddress,
downloadItem.serverUserId,
downloadItem.libraryItemId
)
}
} }
val audioTracks: MutableList<AudioTrack> = mutableListOf() part.completedDestinationUri?.let { contentUrl ->
var foundEBookFile = false val uri = Uri.parse(contentUrl)
val size =
downloadItem.downloadItemParts.forEach { downloadItemPart -> try {
Log.d( ctx.contentResolver.openFileDescriptor(uri, "r")?.use { descriptor ->
tag, descriptor.statSize.coerceAtLeast(0L)
"Scan internal storage item with finalDestinationUri=${downloadItemPart.finalDestinationUri}" }
?: 0L
} catch (e: Exception) {
Log.e(tag, "Could not open completed SAF file: $contentUrl", e)
return null
}
// Android 10 DownloadsProvider may not reconstruct a DocumentFile for an audio URI even
// though the URI remains readable. Keep the URI as the authoritative local-file location.
return LocalFile(
DeviceManager.getBase64Id(contentUrl),
part.filename,
contentUrl,
part.localFolderName,
part.finalDestinationPath,
mimeTypeFor(part),
size
) )
}
val file = File(downloadItemPart.finalDestinationPath) // Do not reconstruct a DocumentFile from an absolute path: on Android 10 that becomes a
Log.d(tag, "Scan internal storage item created file ${file.name}") // file:// URI, which DocumentsContract rejects. The caller resolves this from the persisted
// SAF tree grant instead.
val document = externalFile
if (document == null || !document.exists()) {
Log.e(tag, "Could not resolve downloaded SAF file: ${part.finalDestinationPath}")
return null
}
return LocalFile(
DeviceManager.getBase64Id(document.id),
document.name,
document.uri.toString(),
document.getBasePath(ctx),
document.getAbsolutePath(ctx),
document.mimeType,
document.length()
)
}
if (file == null) { private fun newLocalLibraryItem(
Log.e( id: String,
tag, downloadItem: DownloadItem,
"scanInternalDownloadItem: Null docFile for path ${downloadItemPart.finalDestinationPath}" basePath: String,
) absolutePath: String,
} else { contentUrl: String
if (downloadItemPart.audioTrack != null) { ) =
val audioTrackFromServer = downloadItemPart.audioTrack LocalLibraryItem(
Log.d( id,
tag, downloadItem.localFolder.id,
"scanInternalDownloadItem: Audio Track from Server index = ${audioTrackFromServer.index}" basePath,
absolutePath,
contentUrl,
false,
downloadItem.mediaType,
downloadItem.media.getLocalCopy(),
mutableListOf(),
null,
null,
true,
downloadItem.serverConnectionConfigId,
downloadItem.serverAddress,
downloadItem.serverUserId,
downloadItem.libraryItemId
) )
val localFileId = DeviceManager.getBase64Id(file.name) private fun scanParts(
Log.d(tag, "Scan internal file localFileId=$localFileId") item: DownloadItem,
val localFile = localItem: LocalLibraryItem,
LocalFile( externalFolder: DocumentFile? = null,
localFileId, callback: (DownloadItemScanResult?) -> Unit
file.name, ) {
downloadItemPart.finalDestinationUri.toString(), val tracks = mutableListOf<AudioTrack>()
file.getBasePath(ctx), var foundEbook = false
file.absolutePath, var localEpisodeId: String? = null
file.getSimplePath(ctx),
file.mimeType,
file.length()
)
localLibraryItem.localFiles.add(localFile)
val trackFileMetadata = item.downloadItemParts.forEach { part ->
val externalFile =
if (part.isInternalStorage) {
null
} else {
part.completedDestinationUri?.let { DocumentFileCompat.fromUri(ctx, Uri.parse(it)) }
?: resolveExternalFile(externalFolder, part)
}
Log.d(tag, "Resolve part ${part.filename}: externalFile=${externalFile?.uri}")
val localFile = createLocalFile(part, externalFile) ?: return@forEach
when {
part.audioTrack != null -> {
val serverTrack = part.audioTrack
localItem.localFiles.removeAll { it.id == localFile.id }
localItem.localFiles.add(localFile)
val metadata =
FileMetadata( FileMetadata(
file.name, localFile.filename ?: "",
file.extension, File(localFile.filename ?: "").extension,
file.absolutePath, localFile.absolutePath,
file.getBasePath(ctx), localFile.basePath,
file.length() localFile.size
) )
// Create new audio track
val track = val track =
AudioTrack( AudioTrack(
audioTrackFromServer.index, serverTrack.index,
audioTrackFromServer.startOffset, serverTrack.startOffset,
audioTrackFromServer.duration, serverTrack.duration,
localFile.filename ?: "", localFile.filename ?: "",
localFile.contentUrl, localFile.contentUrl,
localFile.mimeType ?: "", localFile.mimeType ?: "",
trackFileMetadata, metadata,
true, true,
localFileId, localFile.id,
audioTrackFromServer.index serverTrack.index
) )
audioTracks.add(track) tracks.add(track)
Log.d(tag, "Added local audio track ${track.contentUrl} (${track.metadata?.path})")
Log.d( part.episode?.let { episode ->
tag, val podcast = localItem.media as Podcast
"scanInternalDownloadItem: Created Audio Track with index ${track.index} from local file ${localFile.absolutePath}" localEpisodeId = podcast.addEpisode(track, episode).id
)
// Add podcast episodes to library
downloadItemPart.episode?.let { podcastEpisode ->
val podcast = localLibraryItem.media as Podcast
val newEpisode = podcast.addEpisode(track, podcastEpisode)
localEpisodeId = newEpisode.id
Log.d(
tag,
"scanInternalDownloadItem: Added episode to podcast ${podcastEpisode.title} ${track.title} | Track index: ${podcastEpisode.audioTrack?.index}"
)
} }
} else if (downloadItemPart.ebookFile != null) { }
foundEBookFile = true part.ebookFile != null -> {
Log.d(tag, "scanInternalDownloadItem: Ebook file found with mimetype=${file.mimeType}") foundEbook = true
val localFileId = DeviceManager.getBase64Id(file.name) localItem.localFiles.removeAll { it.id == localFile.id }
val localFile = localItem.localFiles.add(localFile)
LocalFile( (localItem.media as Book).ebookFile =
localFileId,
file.name,
Uri.fromFile(file).toString(),
file.getBasePath(ctx),
file.absolutePath,
file.getSimplePath(ctx),
file.mimeType,
file.length()
)
localLibraryItem.localFiles.add(localFile)
val ebookFile =
EBookFile( EBookFile(
downloadItemPart.ebookFile.ino, part.ebookFile.ino,
downloadItemPart.ebookFile.metadata, part.ebookFile.metadata,
downloadItemPart.ebookFile.ebookFormat, part.ebookFile.ebookFormat,
true, true,
localFileId, localFile.id,
localFile.contentUrl localFile.contentUrl
) )
(localLibraryItem.media as Book).ebookFile = ebookFile }
Log.d(tag, "scanInternalDownloadItem: Ebook file added to lli ${localFile.contentUrl}") else -> {
} else { localItem.coverAbsolutePath = localFile.absolutePath
val localFileId = DeviceManager.getBase64Id(file.name) localItem.coverContentUrl = localFile.contentUrl
val localFile = localItem.localFiles.removeAll { it.id == localFile.id }
LocalFile( localItem.localFiles.add(localFile)
localFileId,
file.name,
Uri.fromFile(file).toString(),
file.getBasePath(ctx),
file.absolutePath,
file.getSimplePath(ctx),
file.mimeType,
file.length()
)
localLibraryItem.coverAbsolutePath = localFile.absolutePath
localLibraryItem.coverContentUrl = localFile.contentUrl
localLibraryItem.localFiles.add(localFile)
} }
} }
} }
if (audioTracks.isEmpty() && !foundEBookFile) { if (tracks.isEmpty() && !foundEbook) {
Log.d( callback(null)
tag, return
"scanDownloadItem did not find any audio tracks or ebook file in folder for ${downloadItem.itemFolderPath}"
)
return cb(null)
} }
if (item.mediaType == "book") {
// For books sort audio tracks then set tracks.sortBy { it.index }
if (downloadItem.mediaType == "book") { var expectedIndex = 1
audioTracks.sortBy { it.index } var offset = 0.0
tracks.forEach { track ->
var indexCheck = 1 track.index = expectedIndex++
var startOffset = 0.0 track.startOffset = offset
audioTracks.forEach { audioTrack -> offset += track.duration
if (audioTrack.index != indexCheck || audioTrack.startOffset != startOffset) {
audioTrack.index = indexCheck
audioTrack.startOffset = startOffset
}
indexCheck++
startOffset += audioTrack.duration
} }
localItem.media.setAudioTracks(tracks)
localLibraryItem.media.setAudioTracks(audioTracks)
} }
val downloadItemScanResult = DownloadItemScanResult(localLibraryItem, null) val result = DownloadItemScanResult(localItem, null)
item.userMediaProgress?.let { progress ->
// If library item had media progress then make local media progress and save val progressId =
downloadItem.userMediaProgress?.let { mediaProgress -> if (item.episodeId.isNullOrEmpty()) localItem.id
val localMediaProgressId = else "${localItem.id}-$localEpisodeId"
if (downloadItem.episodeId.isNullOrEmpty()) localLibraryItemId result.localMediaProgress =
else "$localLibraryItemId-$localEpisodeId"
val newLocalMediaProgress =
LocalMediaProgress( LocalMediaProgress(
id = localMediaProgressId, progressId,
localLibraryItemId = localLibraryItemId, localItem.id,
localEpisodeId = localEpisodeId, localEpisodeId,
duration = mediaProgress.duration, progress.duration,
progress = mediaProgress.progress, progress.progress,
currentTime = mediaProgress.currentTime, progress.currentTime,
isFinished = mediaProgress.isFinished, progress.isFinished,
ebookLocation = mediaProgress.ebookLocation, progress.ebookLocation,
ebookProgress = mediaProgress.ebookProgress, progress.ebookProgress,
lastUpdate = mediaProgress.lastUpdate, progress.lastUpdate,
startedAt = mediaProgress.startedAt, progress.startedAt,
finishedAt = mediaProgress.finishedAt, progress.finishedAt,
serverConnectionConfigId = downloadItem.serverConnectionConfigId, item.serverConnectionConfigId,
serverAddress = downloadItem.serverAddress, item.serverAddress,
serverUserId = downloadItem.serverUserId, item.serverUserId,
libraryItemId = downloadItem.libraryItemId, item.libraryItemId,
episodeId = downloadItem.episodeId item.episodeId
) )
Log.d( DeviceManager.dbManager.saveLocalMediaProgress(result.localMediaProgress!!)
tag,
"scanLibraryItemFolder: Saving local media progress ${newLocalMediaProgress.id} at progress ${newLocalMediaProgress.progress}"
)
DeviceManager.dbManager.saveLocalMediaProgress(newLocalMediaProgress)
downloadItemScanResult.localMediaProgress = newLocalMediaProgress
} }
DeviceManager.dbManager.saveLocalLibraryItem(localItem)
DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem) callback(result)
cb(downloadItemScanResult)
} }
// Scan item after download and create local library item private fun findFolderByPath(root: DocumentFile, subPath: String): DocumentFile? {
fun scanDownloadItem(downloadItem: DownloadItem, cb: (DownloadItemScanResult?) -> Unit) { if (subPath.isBlank()) return root
// If downloading to internal storage handle separately var current = root
if (downloadItem.isInternalStorage) { subPath.split('/').filter { it.isNotBlank() }.forEach { segment ->
scanInternalDownloadItem(downloadItem, cb) if (segment == "." || segment == "..") return null
current = current.findFile(segment) ?: return null
}
return current
}
/**
* DownloadsProvider on Android 10 may expose an audio document without its extension through
* DocumentFile.findFile(). Match the manifest first, then match the provider-normalized base
* filename. MIME type and server-reported size are unreliable for Opus on this platform.
*/
private fun resolveExternalFile(folder: DocumentFile?, part: DownloadItemPart): DocumentFile? {
if (folder == null) return null
folder.findFile(part.filename)?.let {
return it
}
val expectedBaseName = part.filename.substringBeforeLast('.')
return folder.listFiles().firstOrNull { document ->
document.name == part.filename ||
document.fullName == part.filename ||
(part.audioTrack != null &&
document.isFile &&
(document.name ?: "").substringBeforeLast('.') == expectedBaseName) ||
(part.audioTrack != null &&
document.isFile &&
document.fullName.substringBeforeLast('.') == expectedBaseName)
}
}
private fun mimeTypeFor(part: DownloadItemPart): String? {
return part.audioTrack?.mimeType
?: when (part.ebookFile?.ebookFormat?.lowercase()) {
"epub" -> "application/epub+zip"
"pdf" -> "application/pdf"
else -> "image/jpeg"
}
}
fun scanDownloadItem(item: DownloadItem, callback: (DownloadItemScanResult?) -> Unit) {
if (item.isInternalStorage) {
val id = "local_${item.libraryItemId}"
val localItem =
DeviceManager.dbManager.getLocalLibraryItem(id)
?: newLocalLibraryItem(id, item, item.itemFolderPath, item.itemFolderPath, "")
scanParts(item, localItem, callback = callback)
return return
} }
val folderDf = DocumentFileCompat.fromUri(ctx, Uri.parse(downloadItem.localFolder.contentUrl)) val root = DocumentFileCompat.fromUri(ctx, Uri.parse(item.localFolder.contentUrl))
val foldersFound = folderDf?.search(true, DocumentFileType.FOLDER) ?: mutableListOf() if (root == null) {
Log.e(tag, "Invalid SAF root: ${item.localFolder.contentUrl}")
var itemFolderId = "" callback(null)
var itemFolderUrl = "" return
var itemFolderBasePath = ""
var itemFolderAbsolutePath = ""
foldersFound.forEach {
// e.g. absolute path is "storage/emulated/0/Audiobooks/Orson Scott Card/Enders Game"
// and itemSubfolder is "Orson Scott Card/Enders Game"
if (it.getAbsolutePath(ctx).endsWith(downloadItem.itemSubfolder)) {
itemFolderId = it.id
itemFolderUrl = it.uri.toString()
itemFolderBasePath = it.getBasePath(ctx)
itemFolderAbsolutePath = it.getAbsolutePath(ctx)
}
} }
val itemFolder = findFolderByPath(root, item.itemSubfolder)
if (itemFolderUrl == "") { if (itemFolder == null) {
Log.d(tag, "scanDownloadItem failed to find media folder") Log.e(tag, "SAF item folder not found: ${item.itemSubfolder}")
return cb(null) callback(null)
return
} }
val df: DocumentFile? = DocumentFileCompat.fromUri(ctx, Uri.parse(itemFolderUrl)) val id = localLibraryItemId(itemFolder.id)
val localItem =
if (df == null) { DeviceManager.dbManager.getLocalLibraryItem(id)
Log.e(tag, "Folder Doc File Invalid ${downloadItem.itemFolderPath}") ?: newLocalLibraryItem(
return cb(null) id,
} item,
itemFolder.getBasePath(ctx),
val localLibraryItemId = getLocalLibraryItemId(itemFolderId) itemFolder.getAbsolutePath(ctx),
Log.d( itemFolder.uri.toString()
tag, )
"scanDownloadItem starting for ${downloadItem.itemFolderPath} | ${df.uri} | Item Folder Id:$itemFolderId | LLI Id:$localLibraryItemId" scanParts(item, localItem, itemFolder, callback)
)
// Search for files in media item folder
// m4b files showing as mimeType application/octet-stream on Android 10 and earlier see #154
val filesFound =
df.search(
false,
DocumentFileType.FILE,
arrayOf("audio/*", "image/*", "video/mp4", "application/*")
)
Log.d(tag, "scanDownloadItem ${filesFound.size} files found in ${downloadItem.itemFolderPath}")
var localEpisodeId: String? = null
var localLibraryItem: LocalLibraryItem?
if (downloadItem.mediaType == "book") {
localLibraryItem =
LocalLibraryItem(
localLibraryItemId,
downloadItem.localFolder.id,
itemFolderBasePath,
itemFolderAbsolutePath,
itemFolderUrl,
false,
downloadItem.mediaType,
downloadItem.media.getLocalCopy(),
mutableListOf(),
null,
null,
true,
downloadItem.serverConnectionConfigId,
downloadItem.serverAddress,
downloadItem.serverUserId,
downloadItem.libraryItemId
)
} else {
// Lookup or create podcast local library item
localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
if (localLibraryItem == null) {
Log.d(
tag,
"[FolderScanner] Podcast local library item not created yet for ${downloadItem.media.metadata.title}"
)
localLibraryItem =
LocalLibraryItem(
localLibraryItemId,
downloadItem.localFolder.id,
itemFolderBasePath,
itemFolderAbsolutePath,
itemFolderUrl,
false,
downloadItem.mediaType,
downloadItem.media.getLocalCopy(),
mutableListOf(),
null,
null,
true,
downloadItem.serverConnectionConfigId,
downloadItem.serverAddress,
downloadItem.serverUserId,
downloadItem.libraryItemId
)
}
}
val audioTracks: MutableList<AudioTrack> = mutableListOf()
var foundEBookFile = false
filesFound.forEach { docFile ->
val itemPart =
downloadItem.downloadItemParts.find { itemPart -> itemPart.filename == docFile.name }
if (itemPart == null) {
if (downloadItem.mediaType == "book"
) { // for books every download item should be a file found
Log.e(
tag,
"scanDownloadItem: Item part not found for doc file ${docFile.name} | ${docFile.getAbsolutePath(ctx)} | ${docFile.uri}"
)
}
} else if (itemPart.audioTrack != null) { // Is audio track
val audioTrackFromServer = itemPart.audioTrack
Log.d(
tag,
"scanDownloadItem: Audio Track from Server index = ${audioTrackFromServer.index}"
)
val localFileId = DeviceManager.getBase64Id(docFile.id)
val localFile =
LocalFile(
localFileId,
docFile.name,
docFile.uri.toString(),
docFile.getBasePath(ctx),
docFile.getAbsolutePath(ctx),
docFile.getSimplePath(ctx),
docFile.mimeType,
docFile.length()
)
localLibraryItem.localFiles.add(localFile)
// Create new audio track
val trackFileMetadata =
FileMetadata(
docFile.name ?: "",
docFile.extension ?: "",
docFile.getAbsolutePath(ctx),
docFile.getBasePath(ctx),
docFile.length()
)
val track =
AudioTrack(
audioTrackFromServer.index,
audioTrackFromServer.startOffset,
audioTrackFromServer.duration,
localFile.filename ?: "",
localFile.contentUrl,
localFile.mimeType ?: "",
trackFileMetadata,
true,
localFileId,
audioTrackFromServer.index
)
audioTracks.add(track)
Log.d(
tag,
"scanDownloadItem: Created Audio Track with index ${track.index} from local file ${localFile.absolutePath}"
)
// Add podcast episodes to library
itemPart.episode?.let { podcastEpisode ->
val podcast = localLibraryItem.media as Podcast
val newEpisode = podcast.addEpisode(track, podcastEpisode)
localEpisodeId = newEpisode.id
Log.d(
tag,
"scanDownloadItem: Added episode to podcast ${podcastEpisode.title} ${track.title} | Track index: ${podcastEpisode.audioTrack?.index}"
)
}
} else if (itemPart.ebookFile != null) { // Ebook
foundEBookFile = true
Log.d(tag, "scanDownloadItem: Ebook file found with mimetype=${docFile.mimeType}")
val localFileId = DeviceManager.getBase64Id(docFile.id)
val localFile =
LocalFile(
localFileId,
docFile.name,
docFile.uri.toString(),
docFile.getBasePath(ctx),
docFile.getAbsolutePath(ctx),
docFile.getSimplePath(ctx),
docFile.mimeType,
docFile.length()
)
localLibraryItem.localFiles.add(localFile)
val ebookFile =
EBookFile(
itemPart.ebookFile.ino,
itemPart.ebookFile.metadata,
itemPart.ebookFile.ebookFormat,
true,
localFileId,
localFile.contentUrl
)
(localLibraryItem.media as Book).ebookFile = ebookFile
Log.d(tag, "scanDownloadItem: Ebook file added to lli ${localFile.contentUrl}")
} else { // Cover image
val localFileId = DeviceManager.getBase64Id(docFile.id)
val localFile =
LocalFile(
localFileId,
docFile.name,
docFile.uri.toString(),
docFile.getBasePath(ctx),
docFile.getAbsolutePath(ctx),
docFile.getSimplePath(ctx),
docFile.mimeType,
docFile.length()
)
localLibraryItem.coverAbsolutePath = localFile.absolutePath
localLibraryItem.coverContentUrl = localFile.contentUrl
localLibraryItem.localFiles.add(localFile)
}
}
if (audioTracks.isEmpty() && !foundEBookFile) {
Log.d(
tag,
"scanDownloadItem did not find any audio tracks or ebook file in folder for ${downloadItem.itemFolderPath}"
)
return cb(null)
}
// For books sort audio tracks then set
if (downloadItem.mediaType == "book") {
audioTracks.sortBy { it.index }
var indexCheck = 1
var startOffset = 0.0
audioTracks.forEach { audioTrack ->
if (audioTrack.index != indexCheck || audioTrack.startOffset != startOffset) {
audioTrack.index = indexCheck
audioTrack.startOffset = startOffset
}
indexCheck++
startOffset += audioTrack.duration
}
localLibraryItem.media.setAudioTracks(audioTracks)
}
val downloadItemScanResult = DownloadItemScanResult(localLibraryItem, null)
// If library item had media progress then make local media progress and save
downloadItem.userMediaProgress?.let { mediaProgress ->
val localMediaProgressId =
if (downloadItem.episodeId.isNullOrEmpty()) localLibraryItemId
else "$localLibraryItemId-$localEpisodeId"
val newLocalMediaProgress =
LocalMediaProgress(
id = localMediaProgressId,
localLibraryItemId = localLibraryItemId,
localEpisodeId = localEpisodeId,
duration = mediaProgress.duration,
progress = mediaProgress.progress,
currentTime = mediaProgress.currentTime,
isFinished = mediaProgress.isFinished,
ebookLocation = mediaProgress.ebookLocation,
ebookProgress = mediaProgress.ebookProgress,
lastUpdate = mediaProgress.lastUpdate,
startedAt = mediaProgress.startedAt,
finishedAt = mediaProgress.finishedAt,
serverConnectionConfigId = downloadItem.serverConnectionConfigId,
serverAddress = downloadItem.serverAddress,
serverUserId = downloadItem.serverUserId,
libraryItemId = downloadItem.libraryItemId,
episodeId = downloadItem.episodeId
)
Log.d(
tag,
"scanLibraryItemFolder: Saving local media progress ${newLocalMediaProgress.id} at progress ${newLocalMediaProgress.progress}"
)
DeviceManager.dbManager.saveLocalMediaProgress(newLocalMediaProgress)
downloadItemScanResult.localMediaProgress = newLocalMediaProgress
}
DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem)
cb(downloadItemScanResult)
} }
} }
android/app/src/main/java/com/audiobookshelf/app/managers/DbManager.kt
+17 -15
View File
@@ -7,7 +7,6 @@ import com.audiobookshelf.app.models.DownloadItem
import com.audiobookshelf.app.plugins.AbsLog import com.audiobookshelf.app.plugins.AbsLog
import com.audiobookshelf.app.plugins.AbsLogger import com.audiobookshelf.app.plugins.AbsLogger
import io.paperdb.Paper import io.paperdb.Paper
import java.io.File
class DbManager { class DbManager {
val tag = "DbManager" val tag = "DbManager"
@@ -148,7 +147,7 @@ class DbManager {
} }
// Make sure all local file ids still exist // Make sure all local file ids still exist
fun cleanLocalLibraryItems() { fun cleanLocalLibraryItems(context: Context) {
val localLibraryItems = getLocalLibraryItems() val localLibraryItems = getLocalLibraryItems()
localLibraryItems.forEach { lli -> localLibraryItems.forEach { lli ->
@@ -157,15 +156,15 @@ class DbManager {
// Check local files // Check local files
lli.localFiles = lli.localFiles =
lli.localFiles.filter { localFile -> lli.localFiles.filter { localFile ->
val file = File(localFile.absolutePath) val exists = localFile.exists(context)
if (!file.exists()) { if (!exists) {
Log.d( Log.d(
tag, tag,
"cleanLocalLibraryItems: Local file ${localFile.absolutePath} was removed from library item ${lli.media.metadata.title}" "cleanLocalLibraryItems: Local file ${localFile.absolutePath} was removed from library item ${lli.media.metadata.title}"
) )
hasUpdates = true hasUpdates = true
} }
file.exists() exists
} as } as
MutableList<LocalFile> MutableList<LocalFile>
@@ -203,9 +202,11 @@ class DbManager {
// Check cover still there // Check cover still there
lli.coverAbsolutePath?.let { lli.coverAbsolutePath?.let {
val coverFile = File(it) val coverExists =
lli.localFiles.any { localFile ->
if (!coverFile.exists()) { localFile.absolutePath == it && localFile.exists(context)
}
if (!coverExists) {
Log.d( Log.d(
tag, tag,
"cleanLocalLibraryItems: Cover $it was removed from library item ${lli.media.metadata.title}" "cleanLocalLibraryItems: Cover $it was removed from library item ${lli.media.metadata.title}"
@@ -290,15 +291,13 @@ class DbManager {
return sessions return sessions
} }
fun saveLog(log:AbsLog) { fun saveLog(log: AbsLog) {
Paper.book("log").write(log.id, log) Paper.book("log").write(log.id, log)
} }
fun getAllLogs() : List<AbsLog> { fun getAllLogs(): List<AbsLog> {
val logs:MutableList<AbsLog> = mutableListOf() val logs: MutableList<AbsLog> = mutableListOf()
Paper.book("log").allKeys.forEach { logId -> Paper.book("log").allKeys.forEach { logId ->
Paper.book("log").read<AbsLog>(logId)?.let { Paper.book("log").read<AbsLog>(logId)?.let { logs.add(it) }
logs.add(it)
}
} }
return logs.sortedBy { it.timestamp } return logs.sortedBy { it.timestamp }
} }
@@ -317,7 +316,10 @@ class DbManager {
} }
} }
if (logsRemoved > 0) { if (logsRemoved > 0) {
AbsLogger.info("DbManager", "cleanLogs: Removed $logsRemoved logs older than $numberOfHoursToKeep hours") AbsLogger.info(
"DbManager",
"cleanLogs: Removed $logsRemoved logs older than $numberOfHoursToKeep hours"
)
} }
} }
} }
android/app/src/main/java/com/audiobookshelf/app/managers/DownloadItemManager.kt
+437 -308
View File
@@ -1,16 +1,10 @@
package com.audiobookshelf.app.managers package com.audiobookshelf.app.managers
import android.app.DownloadManager import android.content.Context
import android.net.Uri import android.net.Uri
import android.os.StatFs
import android.util.Log import android.util.Log
import androidx.documentfile.provider.DocumentFile import androidx.documentfile.provider.DocumentFile
import com.anggrayudi.storage.callback.FileCallback
import com.anggrayudi.storage.file.DocumentFileCompat
import com.anggrayudi.storage.file.MimeType
import com.anggrayudi.storage.file.getAbsolutePath
import com.anggrayudi.storage.file.moveFileTo
import com.anggrayudi.storage.media.FileDescription
import com.audiobookshelf.app.MainActivity
import com.audiobookshelf.app.device.DeviceManager import com.audiobookshelf.app.device.DeviceManager
import com.audiobookshelf.app.device.FolderScanner import com.audiobookshelf.app.device.FolderScanner
import com.audiobookshelf.app.models.DownloadItem import com.audiobookshelf.app.models.DownloadItem
@@ -19,41 +13,44 @@ import com.fasterxml.jackson.core.json.JsonReadFeature
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.getcapacitor.JSObject import com.getcapacitor.JSObject
import java.io.File import java.io.File
import java.io.FileOutputStream import java.io.FileInputStream
import java.util.* import java.util.concurrent.ConcurrentHashMap
import kotlin.math.max
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay import kotlinx.coroutines.delay
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import okhttp3.Call
/** Manages download items and their parts. */ /** Manages the process-owned queue for app-managed downloads. */
class DownloadItemManager( class DownloadItemManager(
var downloadManager: DownloadManager, private val folderScanner: FolderScanner,
private var folderScanner: FolderScanner, private val context: Context,
var mainActivity: MainActivity,
private var clientEventEmitter: DownloadEventEmitter private var clientEventEmitter: DownloadEventEmitter
) { ) {
val tag = "DownloadItemManager" private val tag = "DownloadItemManager"
private val maxSimultaneousDownloads = 3 private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
private var jacksonMapper = private val activeCalls = ConcurrentHashMap<String, Call>()
private val safFolderLocks = ConcurrentHashMap<String, Any>()
private val reservations = mutableMapOf<String, Long>()
private val lastPersistTime = mutableMapOf<String, Long>()
private var watcherRunning = false
private val jacksonMapper =
jacksonObjectMapper() jacksonObjectMapper()
.enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature()) .enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
enum class DownloadCheckStatus { var downloadItemQueue: MutableList<DownloadItem> = mutableListOf()
InProgress, private set
Successful, var currentDownloadItemParts: MutableList<DownloadItemPart> = mutableListOf()
Failed private set
}
var downloadItemQueue: MutableList<DownloadItem> =
mutableListOf() // All pending and downloading items
var currentDownloadItemParts: MutableList<DownloadItemPart> =
mutableListOf() // Item parts currently being downloaded
interface DownloadEventEmitter { interface DownloadEventEmitter {
fun onDownloadItem(downloadItem: DownloadItem) fun onDownloadItem(downloadItem: DownloadItem)
fun onDownloadItemPartUpdate(downloadItemPart: DownloadItemPart) fun onDownloadItemPartUpdate(downloadItemPart: DownloadItemPart)
fun onDownloadItemComplete(jsobj: JSObject) fun onDownloadItemComplete(jsobj: JSObject)
fun onQueueChanged(hasWork: Boolean)
} }
interface InternalProgressCallback { interface InternalProgressCallback {
@@ -61,323 +58,455 @@ class DownloadItemManager(
fun onComplete(failed: Boolean) fun onComplete(failed: Boolean)
} }
companion object { init {
var isDownloading: Boolean = false IncompleteDownloadCleanup.cleanupExpired(context)
} }
/** Adds a download item to the queue and starts processing the queue. */ @Synchronized
fun addDownloadItem(downloadItem: DownloadItem) { fun setEventEmitter(eventEmitter: DownloadEventEmitter) {
DeviceManager.dbManager.saveDownloadItem(downloadItem) clientEventEmitter = eventEmitter
Log.i(tag, "Add download item ${downloadItem.media.metadata.title}") downloadItemQueue.forEach(clientEventEmitter::onDownloadItem)
notifyQueueChanged()
}
@Synchronized
fun restoreQueue() {
if (downloadItemQueue.isNotEmpty()) return
DeviceManager.dbManager.getDownloadItems().forEach { item ->
if (item.isDownloadFinished) {
downloadItemQueue.add(item)
checkDownloadItemFinished(item)
return@forEach
}
item.downloadItemParts.forEach { part ->
if (part.moved) return@forEach
if (item.terminalFailureAt != null && part.failed) return@forEach
part.downloadId = null
part.isMoving = false
part.failed = false
part.completed = false
part.waitingForSpace = false
part.bytesDownloaded = File(part.destinationPath).takeIf(File::exists)?.length() ?: 0L
}
downloadItemQueue.add(item)
if (item.terminalFailureAt != null) IncompleteDownloadCleanup.schedule(context, item)
clientEventEmitter.onDownloadItem(item)
}
checkUpdateDownloadQueue()
notifyQueueChanged()
}
@Synchronized
fun addDownloadItem(downloadItem: DownloadItem) {
val existingItem = downloadItemQueue.find { it.id == downloadItem.id }
if (existingItem != null) {
if (existingItem.terminalFailureAt != null) {
retryDownloadItem(existingItem)
checkUpdateDownloadQueue()
notifyQueueChanged()
}
return
}
persist(downloadItem, force = true)
downloadItemQueue.add(downloadItem) downloadItemQueue.add(downloadItem)
clientEventEmitter.onDownloadItem(downloadItem) clientEventEmitter.onDownloadItem(downloadItem)
checkUpdateDownloadQueue() checkUpdateDownloadQueue()
notifyQueueChanged()
} }
/** Checks and updates the download queue. */ private fun retryDownloadItem(item: DownloadItem) {
item.terminalFailureAt = null
IncompleteDownloadCleanup.cancel(context, item.id)
item.downloadItemParts.filter { it.failed }.forEach { part ->
part.failed = false
part.completed = false
part.isMoving = false
part.downloadId = null
part.retryCount = 0
}
persist(item, force = true)
}
@Synchronized
fun cancelAll() {
activeCalls.values.forEach(Call::cancel)
activeCalls.clear()
downloadItemQueue.forEach { item ->
item.downloadItemParts.forEach { part -> File(part.destinationPath).delete() }
DeviceManager.dbManager.removeDownloadItem(item.id)
}
currentDownloadItemParts.clear()
reservations.clear()
downloadItemQueue.clear()
notifyQueueChanged()
}
@Synchronized
fun hasWork(): Boolean =
downloadItemQueue.any { item ->
item.downloadItemParts.any { part ->
(!part.completed && !part.failed) || part.isMoving
}
}
@Synchronized
private fun checkUpdateDownloadQueue() { private fun checkUpdateDownloadQueue() {
for (downloadItem in downloadItemQueue) { downloadItemQueue.toList().forEach { item ->
val numPartsToGet = maxSimultaneousDownloads - currentDownloadItemParts.size val slots = MAX_SIMULTANEOUS_DOWNLOADS - currentDownloadItemParts.size
val nextDownloadItemParts = downloadItem.getNextDownloadItemParts(numPartsToGet) if (slots <= 0) return@forEach
Log.d( item.getNextDownloadItemParts(slots).forEach { part ->
tag, val existingFile = findSharedStorageFile(part)
"checkUpdateDownloadQueue: numPartsToGet=$numPartsToGet, nextDownloadItemParts=${nextDownloadItemParts.size}" if (existingFile != null) {
) part.bytesDownloaded = existingFile.length()
part.progress = 100L
if (nextDownloadItemParts.isNotEmpty()) { part.completedDestinationUri = existingFile.uri.toString()
processDownloadItemParts(nextDownloadItemParts) File(part.destinationPath).delete()
} completePart(item, part)
clientEventEmitter.onDownloadItemPartUpdate(part)
if (currentDownloadItemParts.size >= maxSimultaneousDownloads) { } else if (tryReserve(part)) startDownload(item, part)
break else {
part.waitingForSpace = true
part.lastUpdateTime = System.currentTimeMillis()
persist(item)
clientEventEmitter.onDownloadItemPartUpdate(part)
}
} }
} }
if (hasWork()) startWatchingDownloads() else notifyQueueChanged()
if (currentDownloadItemParts.isNotEmpty()) startWatchingDownloads()
} }
/** Processes the download item parts. */ private fun startDownload(item: DownloadItem, part: DownloadItemPart) {
private fun processDownloadItemParts(nextDownloadItemParts: List<DownloadItemPart>) { val stagingFile = File(part.destinationPath)
nextDownloadItemParts.forEach { stagingFile.parentFile?.mkdirs()
if (it.isInternalStorage) { part.downloadId = APP_MANAGED_DOWNLOAD_ID
startInternalDownload(it) part.waitingForSpace = false
} else { part.lastUpdateTime = System.currentTimeMillis()
startExternalDownload(it) currentDownloadItemParts.add(part)
} persist(item, force = true)
} val activeConfig = DeviceManager.serverConnectionConfig
val token =
if (activeConfig?.id == item.serverConnectionConfigId) activeConfig.token
else
DeviceManager.getServerConnectionConfig(item.serverConnectionConfigId)?.token
?: DeviceManager.token
activeCalls[part.id] =
InternalDownloadManager(
stagingFile,
part.fileSize,
object : InternalProgressCallback {
override fun onProgress(totalBytesWritten: Long, progress: Long) {
synchronized(this@DownloadItemManager) {
if (part !in currentDownloadItemParts) return
part.bytesDownloaded = totalBytesWritten
part.progress = progress
part.lastUpdateTime = System.currentTimeMillis()
persist(item)
}
}
override fun onComplete(failed: Boolean) {
synchronized(this@DownloadItemManager) {
if (part !in currentDownloadItemParts) return
part.failed = failed
part.completed = !failed
part.lastUpdateTime = System.currentTimeMillis()
activeCalls.remove(part.id)
persist(item, force = true)
}
}
},
{ hasAvailableSpace(part) }
)
.download(serverUrl(item, part), token)
} }
/** Starts an internal download. */ @Synchronized
private fun startInternalDownload(downloadItemPart: DownloadItemPart) {
val file = File(downloadItemPart.finalDestinationPath)
file.parentFile?.mkdirs()
val fileOutputStream = FileOutputStream(downloadItemPart.finalDestinationPath)
val internalProgressCallback =
object : InternalProgressCallback {
override fun onProgress(totalBytesWritten: Long, progress: Long) {
downloadItemPart.bytesDownloaded = totalBytesWritten
downloadItemPart.progress = progress
}
override fun onComplete(failed: Boolean) {
downloadItemPart.failed = failed
downloadItemPart.completed = true
}
}
Log.d(
tag,
"Start internal download to destination path ${downloadItemPart.finalDestinationPath} from ${downloadItemPart.serverUrl}"
)
InternalDownloadManager(fileOutputStream, internalProgressCallback)
.download(downloadItemPart.serverUrl)
downloadItemPart.downloadId = 1
currentDownloadItemParts.add(downloadItemPart)
}
/** Starts an external download. */
private fun startExternalDownload(downloadItemPart: DownloadItemPart) {
val dlRequest = downloadItemPart.getDownloadRequest()
val downloadId = downloadManager.enqueue(dlRequest)
downloadItemPart.downloadId = downloadId
Log.d(tag, "checkUpdateDownloadQueue: Starting download item part, downloadId=$downloadId")
currentDownloadItemParts.add(downloadItemPart)
}
/** Starts watching the downloads. */
private fun startWatchingDownloads() { private fun startWatchingDownloads() {
if (isDownloading) return // Already watching if (watcherRunning) return
watcherRunning = true
GlobalScope.launch(Dispatchers.IO) { scope.launch {
Log.d(tag, "Starting watching downloads") while (true) {
isDownloading = true val activeParts =
synchronized(this@DownloadItemManager) { currentDownloadItemParts.toList() }
while (currentDownloadItemParts.isNotEmpty()) { activeParts.forEach(::handlePartUpdate)
val itemParts = currentDownloadItemParts.filter { !it.isMoving } synchronized(this@DownloadItemManager) {
for (downloadItemPart in itemParts) {
if (downloadItemPart.isInternalStorage) {
handleInternalDownloadPart(downloadItemPart)
} else {
handleExternalDownloadPart(downloadItemPart)
}
}
delay(500)
if (currentDownloadItemParts.size < maxSimultaneousDownloads) {
checkUpdateDownloadQueue() checkUpdateDownloadQueue()
} if (!hasWork()) {
} watcherRunning = false
notifyQueueChanged()
Log.d(tag, "Finished watching downloads") return@launch
isDownloading = false
}
}
/** Handles an internal download part. */
private fun handleInternalDownloadPart(downloadItemPart: DownloadItemPart) {
clientEventEmitter.onDownloadItemPartUpdate(downloadItemPart)
if (downloadItemPart.completed) {
val downloadItem = downloadItemQueue.find { it.id == downloadItemPart.downloadItemId }
downloadItem?.let { checkDownloadItemFinished(it) }
currentDownloadItemParts.remove(downloadItemPart)
}
}
/** Handles an external download part. */
private fun handleExternalDownloadPart(downloadItemPart: DownloadItemPart) {
val downloadCheckStatus = checkDownloadItemPart(downloadItemPart)
clientEventEmitter.onDownloadItemPartUpdate(downloadItemPart)
// Will move to final destination, remove current item parts, and check if download item is
// finished
handleDownloadItemPartCheck(downloadCheckStatus, downloadItemPart)
}
/** Checks the status of a download item part. */
private fun checkDownloadItemPart(downloadItemPart: DownloadItemPart): DownloadCheckStatus {
val downloadId = downloadItemPart.downloadId ?: return DownloadCheckStatus.Failed
val query = DownloadManager.Query().setFilterById(downloadId)
downloadManager.query(query).use {
if (it.moveToFirst()) {
val bytesColumnIndex = it.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES)
val statusColumnIndex = it.getColumnIndex(DownloadManager.COLUMN_STATUS)
val bytesDownloadedColumnIndex =
it.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR)
val totalBytes = if (bytesColumnIndex >= 0) it.getInt(bytesColumnIndex) else 0
val downloadStatus = if (statusColumnIndex >= 0) it.getInt(statusColumnIndex) else 0
val bytesDownloadedSoFar =
if (bytesDownloadedColumnIndex >= 0) it.getLong(bytesDownloadedColumnIndex) else 0
Log.d(
tag,
"checkDownloads Download ${downloadItemPart.filename} bytes $totalBytes | bytes dled $bytesDownloadedSoFar | downloadStatus $downloadStatus"
)
return when (downloadStatus) {
DownloadManager.STATUS_SUCCESSFUL -> {
Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} Successful")
downloadItemPart.completed = true
downloadItemPart.progress = 1
downloadItemPart.bytesDownloaded = bytesDownloadedSoFar
DownloadCheckStatus.Successful
}
DownloadManager.STATUS_FAILED -> {
Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} Failed")
downloadItemPart.completed = true
downloadItemPart.failed = true
DownloadCheckStatus.Failed
}
else -> {
val percentProgress =
if (totalBytes > 0) ((bytesDownloadedSoFar * 100L) / totalBytes) else 0
Log.d(
tag,
"checkDownloads Download ${downloadItemPart.filename} Progress = $percentProgress%"
)
downloadItemPart.progress = percentProgress
downloadItemPart.bytesDownloaded = bytesDownloadedSoFar
DownloadCheckStatus.InProgress
} }
} }
} else { delay(WATCH_INTERVAL_MS)
Log.d(tag, "Download ${downloadItemPart.filename} not found in dlmanager")
downloadItemPart.completed = true
downloadItemPart.failed = true
return DownloadCheckStatus.Failed
} }
} }
} }
/** Handles the result of a download item part check. */ private fun handlePartUpdate(part: DownloadItemPart) {
private fun handleDownloadItemPartCheck( clientEventEmitter.onDownloadItemPartUpdate(part)
downloadCheckStatus: DownloadCheckStatus, val item =
downloadItemPart: DownloadItemPart synchronized(this) { downloadItemQueue.find { it.id == part.downloadItemId } }
) { ?: run {
val downloadItem = downloadItemQueue.find { it.id == downloadItemPart.downloadItemId } removeActivePart(part)
if (downloadItem == null) { return
Log.e( }
tag, if (!part.completed && !part.failed) {
"Download item part finished but download item not found ${downloadItemPart.filename}" val lastUpdate = part.lastUpdateTime ?: return
) if (System.currentTimeMillis() - lastUpdate > STALL_TIMEOUT_MS) {
currentDownloadItemParts.remove(downloadItemPart) Log.w(tag, "Download stalled: ${part.filename}")
} else if (downloadCheckStatus == DownloadCheckStatus.Successful) { activeCalls.remove(part.id)?.cancel()
moveDownloadedFile(downloadItem, downloadItemPart) failOrRetry(item, part, "Download stalled")
} else if (downloadCheckStatus != DownloadCheckStatus.InProgress) { }
checkDownloadItemFinished(downloadItem) return
currentDownloadItemParts.remove(downloadItemPart) }
if (part.failed) {
failOrRetry(item, part, "Transfer failed")
return
}
if (part.isInternalStorage) finalizeInternalFile(item, part) else moveDownloadedFile(item, part)
}
@Synchronized
private fun failOrRetry(item: DownloadItem, part: DownloadItemPart, reason: String) {
removeActivePart(part)
part.retryCount += 1
reservations.remove(part.destinationPath)
if (part.retryCount > MAX_RETRIES) {
Log.e(tag, "$reason after $MAX_RETRIES retries: ${part.filename}")
part.failed = true
part.completed = false
part.downloadId = null
item.terminalFailureAt = item.terminalFailureAt ?: System.currentTimeMillis()
persist(item, force = true)
IncompleteDownloadCleanup.schedule(context, item)
notifyQueueChanged()
return
}
part.failed = false
part.completed = false
part.downloadId = null
part.isMoving = false
persist(item, force = true)
}
private fun finalizeInternalFile(item: DownloadItem, part: DownloadItemPart) {
if (part.moved || part.isMoving) return
part.isMoving = true
val stagingFile = File(part.destinationPath)
val finalFile = File(part.finalDestinationPath)
finalFile.parentFile?.mkdirs()
val backup = File(finalFile.parentFile, ".${finalFile.name}.abs-backup")
try {
if (backup.exists() && !backup.delete()) throw IllegalStateException("Could not clear backup")
if (finalFile.exists() && !finalFile.renameTo(backup))
throw IllegalStateException("Could not protect existing file")
if (!stagingFile.renameTo(finalFile)) {
if (backup.exists()) backup.renameTo(finalFile)
throw IllegalStateException("Could not finalize internal staging file")
}
backup.delete()
completePart(item, part)
} catch (e: Exception) {
part.isMoving = false
part.failed = true
failOrRetry(item, part, e.message ?: "Internal finalization failed")
} }
} }
/** Moves the downloaded file to its final destination. */ private fun moveDownloadedFile(item: DownloadItem, part: DownloadItemPart) {
private fun moveDownloadedFile(downloadItem: DownloadItem, downloadItemPart: DownloadItemPart) { if (part.moved || part.isMoving) return
val file = DocumentFileCompat.fromUri(mainActivity, downloadItemPart.destinationUri) val root =
Log.d(tag, "DOWNLOAD: DESTINATION URI ${downloadItemPart.destinationUri}") DocumentFile.fromTreeUri(context, Uri.parse(part.localFolderUrl))
?: return failFinalization(item, part, "Could not resolve SAF destination")
part.isMoving = true
persist(item, force = true)
scope.launch {
try {
if (!hasAvailableSpace(part))
throw IllegalStateException("Insufficient storage for SAF copy")
val folderKey = "${root.uri}/${part.finalDestinationSubfolder}"
val folderLock = safFolderLocks.computeIfAbsent(folderKey) { Any() }
val folder =
synchronized(folderLock) { getOrCreateFolder(root, part.finalDestinationSubfolder) }
?: throw IllegalStateException("Could not create SAF destination folder")
val temporaryName = ".${part.filename}.${part.id.hashCode()}.part"
folder.findFile(temporaryName)?.delete()
val temporary =
folder.createFile(mimeTypeFor(part), temporaryName)
?: throw IllegalStateException("Could not create SAF temporary file")
val staging = File(part.destinationPath)
FileInputStream(staging).use { input ->
context.contentResolver.openOutputStream(temporary.uri, "w")?.use { input.copyTo(it) }
?: throw IllegalStateException("Could not open SAF output stream")
}
if (temporary.length() != staging.length())
throw IllegalStateException("SAF copy size mismatch")
val existing = folder.findFile(part.filename)
if (existing != null && !existing.delete())
throw IllegalStateException("Could not replace existing file")
if (!temporary.renameTo(part.filename))
throw IllegalStateException("Could not finalize SAF temporary file")
val destination =
folder.findFile(part.filename)
?: throw IllegalStateException("Could not reopen finalized SAF file")
if (destination.length() != staging.length())
throw IllegalStateException("SAF final size mismatch")
if (!staging.delete()) Log.w(tag, "Could not remove staging file ${staging.name}")
part.completedDestinationUri = destination.uri.toString()
completePart(item, part)
} catch (e: Exception) {
failFinalization(item, part, "SAF copy failed: ${e.message}")
}
}
}
val fcb = @Synchronized
object : FileCallback() { private fun failFinalization(item: DownloadItem, part: DownloadItemPart, message: String) {
override fun onPrepare() { Log.e(tag, message)
Log.d(tag, "DOWNLOAD: PREPARING MOVE FILE") part.isMoving = false
} part.failed = true
failOrRetry(item, part, message)
}
override fun onFailed(errorCode: ErrorCode) { @Synchronized
Log.e(tag, "DOWNLOAD: FAILED TO MOVE FILE $errorCode") private fun completePart(item: DownloadItem, part: DownloadItemPart) {
downloadItemPart.failed = true part.moved = true
downloadItemPart.isMoving = false part.completed = true
file?.delete() part.failed = false
checkDownloadItemFinished(downloadItem) part.isMoving = false
currentDownloadItemParts.remove(downloadItemPart) reservations.remove(part.destinationPath)
} removeActivePart(part)
persist(item, force = true)
checkDownloadItemFinished(item)
}
override fun onCompleted(result: Any) { private fun checkDownloadItemFinished(item: DownloadItem) {
Log.d(tag, "DOWNLOAD: FILE MOVE COMPLETED") if (!item.isDownloadFinished) return
val resultDocFile = result as DocumentFile scope.launch {
Log.d( folderScanner.scanDownloadItem(item) { scanResult ->
tag, val event =
"DOWNLOAD: COMPLETED FILE INFO (name=${resultDocFile.name}) ${resultDocFile.getAbsolutePath(mainActivity)}" JSObject().apply {
) put("libraryItemId", item.id)
put("localFolderId", item.localFolder.id)
// Rename to fix appended .mp3 on m4b/m4a files scanResult?.localLibraryItem?.let {
// REF: https://github.com/anggrayudi/SimpleStorage/issues/94 put("localLibraryItem", JSObject(jacksonMapper.writeValueAsString(it)))
val docNameLowerCase = resultDocFile.name?.lowercase(Locale.getDefault()) ?: "" }
if (docNameLowerCase.endsWith(".m4b.mp3") || docNameLowerCase.endsWith(".m4a.mp3") scanResult?.localMediaProgress?.let {
) { put("localMediaProgress", JSObject(jacksonMapper.writeValueAsString(it)))
resultDocFile.renameTo(downloadItemPart.filename) }
} }
clientEventEmitter.onDownloadItemComplete(event)
downloadItemPart.moved = true synchronized(this@DownloadItemManager) {
downloadItemPart.isMoving = false downloadItemQueue.remove(item)
checkDownloadItemFinished(downloadItem) DeviceManager.dbManager.removeDownloadItem(item.id)
currentDownloadItemParts.remove(downloadItemPart) notifyQueueChanged()
} }
} }
val localFolderFile =
DocumentFileCompat.fromUri(mainActivity, Uri.parse(downloadItemPart.localFolderUrl))
if (localFolderFile == null) {
// Failed
downloadItemPart.failed = true
Log.e(tag, "Local Folder File from uri is null")
checkDownloadItemFinished(downloadItem)
currentDownloadItemParts.remove(downloadItemPart)
} else {
downloadItemPart.isMoving = true
val mimetype = if (downloadItemPart.audioTrack != null) MimeType.AUDIO else MimeType.IMAGE
val fileDescription =
FileDescription(
downloadItemPart.filename,
downloadItemPart.finalDestinationSubfolder,
mimetype
)
file?.moveFileTo(mainActivity, localFolderFile, fileDescription, fcb)
} }
} }
/** Checks if a download item is finished and processes it. */ private fun tryReserve(part: DownloadItemPart): Boolean {
private fun checkDownloadItemFinished(downloadItem: DownloadItem) { if (part.fileSize <= 0L && currentDownloadItemParts.any { it.fileSize <= 0L }) return false
if (downloadItem.isDownloadFinished) { val staging = File(part.destinationPath)
Log.i(tag, "Download Item finished ${downloadItem.media.metadata.title}") staging.parentFile?.mkdirs()
val expectedSize = if (part.fileSize > 0L) part.fileSize else UNKNOWN_PART_RESERVATION_BYTES
val remaining =
(expectedSize - (staging.takeIf(File::exists)?.length() ?: 0L)).coerceAtLeast(0L)
val required = if (part.isInternalStorage) remaining else remaining + expectedSize
val key = storageKey(staging)
val fs = statFsFor(staging)
val headroom = max(MIN_FREE_SPACE_BYTES, fs.totalBytes / 20L)
val alreadyReserved = reservations.filterKeys { storageKey(File(it)) == key }.values.sum()
if (fs.availableBytes - alreadyReserved < required + headroom) return false
reservations[part.destinationPath] = required
return true
}
GlobalScope.launch(Dispatchers.IO) { private fun hasAvailableSpace(part: DownloadItemPart): Boolean {
folderScanner.scanDownloadItem(downloadItem) { downloadItemScanResult -> val staging = File(part.destinationPath)
Log.d( val fs = statFsFor(staging)
tag, return fs.availableBytes >= max(MIN_FREE_SPACE_BYTES, fs.totalBytes / 20L)
"Item download complete ${downloadItem.itemTitle} | local library item id: ${downloadItemScanResult?.localLibraryItem?.id}" }
)
val jsobj = private fun statFsFor(staging: File): StatFs {
JSObject().apply { var directory = staging.parentFile ?: context.filesDir
put("libraryItemId", downloadItem.id) directory.mkdirs()
put("localFolderId", downloadItem.localFolder.id) while (!directory.exists()) directory = directory.parentFile ?: context.filesDir
return StatFs(directory.absolutePath)
}
downloadItemScanResult?.localLibraryItem?.let { localLibraryItem -> private fun storageKey(file: File): String =
put( if (file.absolutePath.startsWith(context.filesDir.absolutePath)) "internal"
"localLibraryItem", else "external"
JSObject(jacksonMapper.writeValueAsString(localLibraryItem))
) @Synchronized
} private fun removeActivePart(part: DownloadItemPart) {
downloadItemScanResult?.localMediaProgress?.let { localMediaProgress -> activeCalls.remove(part.id)
put( currentDownloadItemParts.remove(part)
"localMediaProgress", }
JSObject(jacksonMapper.writeValueAsString(localMediaProgress))
) private fun persist(item: DownloadItem, force: Boolean = false) {
} val now = System.currentTimeMillis()
if (!force && now - (lastPersistTime[item.id] ?: 0L) < PERSIST_INTERVAL_MS) return
lastPersistTime[item.id] = now
DeviceManager.dbManager.saveDownloadItem(item)
}
private fun notifyQueueChanged() {
clientEventEmitter.onQueueChanged(hasWork())
}
fun destroy() {
activeCalls.values.forEach(Call::cancel)
activeCalls.clear()
scope.cancel()
}
private fun getOrCreateFolder(root: DocumentFile, relativePath: String): DocumentFile? {
var current = root
relativePath.split('/').filter { it.isNotBlank() }.forEach { segment ->
if (segment == "." || segment == "..") return null
current = current.findFile(segment) ?: current.createDirectory(segment) ?: return null
}
return current
}
private fun findSharedStorageFile(part: DownloadItemPart): DocumentFile? {
if (part.isInternalStorage) return null
val root = DocumentFile.fromTreeUri(context, Uri.parse(part.localFolderUrl)) ?: return null
var folder = root
part.finalDestinationSubfolder.split('/').filter { it.isNotBlank() }.forEach { segment ->
if (segment == "." || segment == "..") return null
folder = folder.findFile(segment) ?: return null
}
val file = folder.findFile(part.filename) ?: return null
if (!file.isFile) return null
if (part.fileSize > 0L && file.length() != part.fileSize) return null
if (part.fileSize <= 0L && file.length() <= 0L) return null
return file
}
private fun mimeTypeFor(part: DownloadItemPart): String =
part.audioTrack?.mimeType
?: when (part.ebookFile?.ebookFormat?.lowercase()) {
"epub" -> "application/epub+zip"
"pdf" -> "application/pdf"
else -> "image/jpeg"
} }
launch(Dispatchers.Main) { private fun serverUrl(item: DownloadItem, part: DownloadItemPart): String {
clientEventEmitter.onDownloadItemComplete(jsobj) val rawCover = if (part.serverPath.endsWith("/cover")) "?raw=1" else ""
downloadItemQueue.remove(downloadItem) return "${item.serverAddress}${part.serverPath}$rawCover"
DeviceManager.dbManager.removeDownloadItem(downloadItem.id) }
}
} private companion object {
} const val APP_MANAGED_DOWNLOAD_ID = -1L
} const val MAX_SIMULTANEOUS_DOWNLOADS = 3
const val WATCH_INTERVAL_MS = 1_000L
const val STALL_TIMEOUT_MS = 60_000L
const val MAX_RETRIES = 5
const val PERSIST_INTERVAL_MS = 2_000L
const val MIN_FREE_SPACE_BYTES = 100L * 1024L * 1024L
const val UNKNOWN_PART_RESERVATION_BYTES = 100L * 1024L * 1024L
} }
} }
android/app/src/main/java/com/audiobookshelf/app/managers/IncompleteDownloadCleanup.kt
+94
View File
@@ -0,0 +1,94 @@
package com.audiobookshelf.app.managers
import android.content.Context
import android.net.Uri
import android.util.Log
import androidx.documentfile.provider.DocumentFile
import androidx.work.ExistingWorkPolicy
import androidx.work.OneTimeWorkRequestBuilder
import androidx.work.WorkManager
import androidx.work.Worker
import androidx.work.WorkerParameters
import com.audiobookshelf.app.device.DeviceManager
import com.audiobookshelf.app.models.DownloadItem
import java.io.File
import java.util.concurrent.TimeUnit
/** Removes terminally failed downloads after their retention window elapses. */
object IncompleteDownloadCleanup {
private const val tag = "IncompleteDownloadCleanup"
private const val RETENTION_MS = 24L * 60L * 60L * 1000L
private const val WORK_PREFIX = "incomplete-download-"
fun schedule(context: Context, item: DownloadItem) {
val failedAt = item.terminalFailureAt ?: return
val delay = (failedAt + RETENTION_MS - System.currentTimeMillis()).coerceAtLeast(0L)
val request = OneTimeWorkRequestBuilder<IncompleteDownloadCleanupWorker>()
.setInitialDelay(delay, TimeUnit.MILLISECONDS)
.build()
WorkManager.getInstance(context).enqueueUniqueWork(
WORK_PREFIX + item.id, ExistingWorkPolicy.REPLACE, request)
}
fun cancel(context: Context, itemId: String) {
WorkManager.getInstance(context).cancelUniqueWork(WORK_PREFIX + itemId)
}
/** Removes failures retained longer than 24 hours when scheduled work did not run. */
fun cleanupExpired(context: Context) {
val now = System.currentTimeMillis()
DeviceManager.dbManager.getDownloadItems()
.filter { item -> isEligible(item, now) }
.forEach { item ->
deleteItem(context, item)
}
}
private fun isEligible(item: DownloadItem, now: Long): Boolean {
val failedAt = item.terminalFailureAt ?: return false
if (now - failedAt < RETENTION_MS) return false
return item.downloadItemParts.all { part ->
part.moved || (part.failed && !part.isMoving)
}
}
private fun deleteItem(context: Context, item: DownloadItem) {
item.downloadItemParts.forEach { part ->
deleteAppOwnedFile(context, File(part.destinationPath))
if (part.isInternalStorage && part.moved) {
deleteAppOwnedFile(context, File(part.finalDestinationPath))
} else if (!part.isInternalStorage && part.moved) {
part.completedDestinationUri?.let { uriString ->
try {
DocumentFile.fromSingleUri(context, Uri.parse(uriString))?.delete()
} catch (e: Exception) {
Log.w(tag, "Could not delete expired SAF document for ${part.filename}", e)
}
}
}
}
DeviceManager.dbManager.removeDownloadItem(item.id)
cancel(context, item.id)
Log.i(tag, "Deleted terminally failed download item ${item.id}")
}
private fun deleteAppOwnedFile(context: Context, file: File) {
val path = file.absolutePath
val internal = context.filesDir.absolutePath
val external = context.getExternalFilesDir(null)?.absolutePath
if (path.startsWith(internal) || (external != null && path.startsWith(external))) {
if (file.exists() && !file.delete()) Log.w(tag, "Could not delete expired staging file $path")
file.parentFile?.takeIf { it.isDirectory && it.list()?.isEmpty() == true }?.delete()
} else {
Log.w(tag, "Refusing to delete non-app-owned path $path")
}
}
}
class IncompleteDownloadCleanupWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
override fun doWork(): Result {
DbManager.initialize(applicationContext)
IncompleteDownloadCleanup.cleanupExpired(applicationContext)
return Result.success()
}
}
android/app/src/main/java/com/audiobookshelf/app/managers/InternalDownloadManager.kt
+117 -96
View File
@@ -1,114 +1,135 @@
package com.audiobookshelf.app.managers package com.audiobookshelf.app.managers
import android.util.Log import android.util.Log
import java.io.* import java.io.File
import java.io.FileOutputStream
import java.io.IOException
import java.util.concurrent.TimeUnit import java.util.concurrent.TimeUnit
import okhttp3.* import okhttp3.Call
import okhttp3.Callback
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
/** /** Streams a download into an app-owned staging file. */
* Manages the internal download process.
*
* @property outputStream The output stream to write the downloaded data.
* @property progressCallback The callback to report download progress.
*/
class InternalDownloadManager( class InternalDownloadManager(
private val outputStream: FileOutputStream, private val destinationFile: File,
private val progressCallback: DownloadItemManager.InternalProgressCallback private val expectedSize: Long,
) : AutoCloseable { private val progressCallback: DownloadItemManager.InternalProgressCallback,
private val hasAvailableSpace: () -> Boolean
) {
private val tag = "InternalDownloadManager" private val tag = "InternalDownloadManager"
private val client: OkHttpClient =
OkHttpClient.Builder().connectTimeout(30, TimeUnit.SECONDS).build()
private val writer = BinaryFileWriter(outputStream, progressCallback)
/** /**
* Downloads a file from the given URL. * Starts or resumes a download.
* *
* @param url The URL to download the file from. * @param url download URL
* @throws IOException If an I/O error occurs. * @param token access token sent in the Authorization header
* @return active call, used to cancel a stalled transfer
*/ */
@Throws(IOException::class) fun download(url: String, token: String): Call {
fun download(url: String) { destinationFile.parentFile?.mkdirs()
val request: Request = Request.Builder().url(url).addHeader("Accept-Encoding", "identity").build() val existingBytes = destinationFile.takeIf { it.exists() }?.length() ?: 0L
client.newCall(request) val request =
.enqueue( Request.Builder()
object : Callback { .url(url)
override fun onFailure(call: Call, e: IOException) { .addHeader("Accept-Encoding", "identity")
Log.e(tag, "Download URL $url FAILED", e) .addHeader("Authorization", "Bearer $token")
progressCallback.onComplete(true) .apply { if (existingBytes > 0L) header("Range", "bytes=$existingBytes-") }
} .build()
val call = client.newCall(request)
call.enqueue(
object : Callback {
override fun onFailure(call: Call, e: IOException) {
Log.e(tag, "Download URL failed", e)
progressCallback.onComplete(true)
}
override fun onResponse(call: Call, response: Response) { override fun onResponse(call: Call, response: Response) {
response.body?.let { responseBody -> response.use {
val length: Long = response.header("Content-Length")?.toLongOrNull() ?: 0L try {
writer.write(responseBody.byteStream(), length) if (response.code == 416 && expectedSize > 0L && existingBytes == expectedSize
) {
progressCallback.onProgress(existingBytes, 100L)
progressCallback.onComplete(false)
return
}
val append =
existingBytes > 0L &&
response.code == 206 &&
hasExpectedRange(response, existingBytes)
if (existingBytes > 0L && !append && response.code != 200) {
Log.e(
tag,
"Invalid resume response ${response.code} for offset $existingBytes"
)
progressCallback.onComplete(true)
return
}
if (!response.isSuccessful || response.body == null) {
Log.e(tag, "Download HTTP failure ${response.code}")
progressCallback.onComplete(true)
return
}
val startingBytes = if (append) existingBytes else 0L
val responseLength = response.body!!.contentLength()
val totalLength =
if (expectedSize > 0L) expectedSize
else if (responseLength >= 0L) startingBytes + responseLength else 0L
FileOutputStream(destinationFile, append).use { output ->
response.body!!.byteStream().use { input ->
val buffer = ByteArray(CHUNK_SIZE)
var totalBytes = startingBytes
while (true) {
val read = input.read(buffer)
if (read < 0) break
if (!hasAvailableSpace())
throw IOException("Download paused to preserve free storage")
output.write(buffer, 0, read)
totalBytes += read
val progress =
if (totalLength > 0L) (totalBytes * 100L) / totalLength else 0L
progressCallback.onProgress(totalBytes, progress.coerceAtMost(100L))
} }
?: run {
Log.e(tag, "Response doesn't contain a file")
progressCallback.onComplete(true)
}
} }
} }
)
if (expectedSize > 0L && destinationFile.length() != expectedSize) {
Log.e(
tag,
"Downloaded size ${destinationFile.length()} did not match $expectedSize"
)
progressCallback.onComplete(true)
} else {
progressCallback.onComplete(false)
}
} catch (e: IOException) {
Log.e(tag, "Could not write staging file", e)
progressCallback.onComplete(true)
}
}
}
}
)
return call
} }
/** private fun hasExpectedRange(response: Response, offset: Long): Boolean {
* Closes the download manager and releases resources. val range = response.header("Content-Range") ?: return false
* val match = CONTENT_RANGE.matchEntire(range) ?: return false
* @throws Exception If an error occurs during closing. return match.groupValues[1].toLongOrNull() == offset &&
*/ match.groupValues[2].toLongOrNull()?.let { it >= offset } == true
@Throws(Exception::class) }
override fun close() {
writer.close() private companion object {
} const val CHUNK_SIZE = 512 * 1024 // 512 KB
} val CONTENT_RANGE = Regex("bytes (\\d+)-(\\d+)/(?:\\d+|\\*)")
val client =
/** OkHttpClient.Builder()
* Writes binary data to an output stream. .connectTimeout(30, TimeUnit.SECONDS)
* .readTimeout(60, TimeUnit.SECONDS)
* @property outputStream The output stream to write the data to. .writeTimeout(60, TimeUnit.SECONDS)
* @property progressCallback The callback to report write progress. .build()
*/
class BinaryFileWriter(
private val outputStream: OutputStream,
private val progressCallback: DownloadItemManager.InternalProgressCallback
) : AutoCloseable {
/**
* Writes data from the input stream to the output stream.
*
* @param inputStream The input stream to read the data from.
* @param length The total length of the data to be written.
* @return The total number of bytes written.
* @throws IOException If an I/O error occurs.
*/
@Throws(IOException::class)
fun write(inputStream: InputStream, length: Long): Long {
BufferedInputStream(inputStream).use { input ->
val dataBuffer = ByteArray(CHUNK_SIZE)
var totalBytes: Long = 0
var readBytes: Int
while (input.read(dataBuffer).also { readBytes = it } != -1) {
totalBytes += readBytes
outputStream.write(dataBuffer, 0, readBytes)
progressCallback.onProgress(totalBytes, (totalBytes * 100L) / length)
}
progressCallback.onComplete(false)
return totalBytes
}
}
/**
* Closes the writer and releases resources.
*
* @throws IOException If an error occurs during closing.
*/
@Throws(IOException::class)
override fun close() {
outputStream.close()
}
companion object {
private const val CHUNK_SIZE = 8192 // Increased chunk size for better performance
} }
} }
android/app/src/main/java/com/audiobookshelf/app/models/DownloadItem.kt
+21 -18
View File
@@ -6,34 +6,37 @@ import com.audiobookshelf.app.data.MediaType
import com.fasterxml.jackson.annotation.JsonIgnore import com.fasterxml.jackson.annotation.JsonIgnore
data class DownloadItem( data class DownloadItem(
val id: String, val id: String,
val libraryItemId:String, val libraryItemId: String,
val episodeId:String?, val episodeId: String?,
val userMediaProgress: MediaProgress?, val userMediaProgress: MediaProgress?,
val serverConnectionConfigId:String, val serverConnectionConfigId: String,
val serverAddress:String, val serverAddress: String,
val serverUserId:String, val serverUserId: String,
val mediaType: String, val mediaType: String,
val itemFolderPath:String, val itemFolderPath: String,
val localFolder: LocalFolder, val localFolder: LocalFolder,
val itemTitle: String, val itemTitle: String,
val itemSubfolder: String, val itemSubfolder: String,
val media: MediaType, val media: MediaType,
val downloadItemParts: MutableList<DownloadItemPart> val downloadItemParts: MutableList<DownloadItemPart>,
@JsonIgnore var terminalFailureAt: Long? = null
) { ) {
@get:JsonIgnore @get:JsonIgnore
val isInternalStorage get() = localFolder.id.startsWith("internal-") val isInternalStorage
get() = localFolder.id.startsWith("internal-")
@get:JsonIgnore @get:JsonIgnore
val isDownloadFinished get() = !downloadItemParts.any { !it.completed || it.isMoving } val isDownloadFinished
get() = !downloadItemParts.any { !it.completed || it.isMoving || it.failed }
@JsonIgnore @JsonIgnore
fun getNextDownloadItemParts(limit:Int): MutableList<DownloadItemPart> { fun getNextDownloadItemParts(limit: Int): MutableList<DownloadItemPart> {
val itemParts = mutableListOf<DownloadItemPart>() val itemParts = mutableListOf<DownloadItemPart>()
if (limit == 0) return itemParts if (limit == 0) return itemParts
for (it in downloadItemParts) { for (it in downloadItemParts) {
if (!it.completed && it.downloadId == null) { if (!it.completed && !it.failed && it.downloadId == null) {
itemParts.add(it) itemParts.add(it)
if (itemParts.size >= limit) break if (itemParts.size >= limit) break
} }
android/app/src/main/java/com/audiobookshelf/app/models/DownloadItemPart.kt
+11 -20
View File
@@ -1,6 +1,5 @@
package com.audiobookshelf.app.models package com.audiobookshelf.app.models
import android.app.DownloadManager
import android.net.Uri import android.net.Uri
import android.util.Log import android.util.Log
import com.audiobookshelf.app.data.AudioTrack import com.audiobookshelf.app.data.AudioTrack
@@ -16,6 +15,7 @@ data class DownloadItemPart(
val downloadItemId: String, val downloadItemId: String,
val filename: String, val filename: String,
val fileSize: Long, val fileSize: Long,
@JsonIgnore val destinationPath: String,
val finalDestinationPath:String, val finalDestinationPath:String,
val serverPath: String, val serverPath: String,
val localFolderName: String, val localFolderName: String,
@@ -31,28 +31,29 @@ data class DownloadItemPart(
@JsonIgnore val uri: Uri, @JsonIgnore val uri: Uri,
@JsonIgnore val destinationUri: Uri, @JsonIgnore val destinationUri: Uri,
@JsonIgnore val finalDestinationUri: Uri, @JsonIgnore val finalDestinationUri: Uri,
@JsonIgnore var completedDestinationUri: String?,
val finalDestinationSubfolder: String, val finalDestinationSubfolder: String,
var downloadId: Long?, var downloadId: Long?,
@JsonIgnore var lastUpdateTime: Long?,
var progress: Long, var progress: Long,
var bytesDownloaded: Long var bytesDownloaded: Long,
@JsonIgnore var retryCount: Int = 0,
@JsonIgnore var waitingForSpace: Boolean = false
) { ) {
companion object { companion object {
fun make(downloadItemId:String, filename:String, fileSize: Long, destinationFile: File, finalDestinationFile: File, subfolder:String, serverPath:String, localFolder: LocalFolder, ebookFile: EBookFile?, audioTrack: AudioTrack?, episode: PodcastEpisode?) :DownloadItemPart { fun make(downloadItemId:String, filename:String, fileSize: Long, destinationFile: File, finalDestinationFile: File, subfolder:String, serverPath:String, localFolder: LocalFolder, ebookFile: EBookFile?, audioTrack: AudioTrack?, episode: PodcastEpisode?) :DownloadItemPart {
val destinationUri = Uri.fromFile(destinationFile) val destinationUri = Uri.fromFile(destinationFile)
val finalDestinationUri = Uri.fromFile(finalDestinationFile) val finalDestinationUri = Uri.fromFile(finalDestinationFile)
val rawCover = if (serverPath.endsWith("/cover")) "?raw=1" else ""
val downloadUri = Uri.parse("${DeviceManager.serverAddress}${serverPath}$rawCover")
var downloadUrl = "${DeviceManager.serverAddress}${serverPath}?token=${DeviceManager.token}"
if (serverPath.endsWith("/cover")) {
downloadUrl += "&raw=1" // Download raw cover image
}
val downloadUri = Uri.parse(downloadUrl)
Log.d("DownloadItemPart", "Audio File Destination Uri: $destinationUri | Final Destination Uri: $finalDestinationUri | Server Path $serverPath") Log.d("DownloadItemPart", "Audio File Destination Uri: $destinationUri | Final Destination Uri: $finalDestinationUri | Server Path $serverPath")
return DownloadItemPart( return DownloadItemPart(
id = DeviceManager.getBase64Id(finalDestinationFile.absolutePath), id = DeviceManager.getBase64Id(finalDestinationFile.absolutePath),
downloadItemId, downloadItemId,
filename = filename, filename = filename,
fileSize = fileSize, fileSize = fileSize,
destinationPath = destinationFile.absolutePath,
finalDestinationPath = finalDestinationFile.absolutePath, finalDestinationPath = finalDestinationFile.absolutePath,
serverPath = serverPath, serverPath = serverPath,
localFolderName = localFolder.name, localFolderName = localFolder.name,
@@ -68,8 +69,10 @@ data class DownloadItemPart(
uri = downloadUri, uri = downloadUri,
destinationUri = destinationUri, destinationUri = destinationUri,
finalDestinationUri = finalDestinationUri, finalDestinationUri = finalDestinationUri,
completedDestinationUri = null,
finalDestinationSubfolder = subfolder, finalDestinationSubfolder = subfolder,
downloadId = null, downloadId = null,
lastUpdateTime = null,
progress = 0, progress = 0,
bytesDownloaded = 0 bytesDownloaded = 0
) )
@@ -79,16 +82,4 @@ data class DownloadItemPart(
@get:JsonIgnore @get:JsonIgnore
val isInternalStorage get() = localFolderId.startsWith("internal-") val isInternalStorage get() = localFolderId.startsWith("internal-")
@get:JsonIgnore
val serverUrl get() = uri.toString()
@JsonIgnore
fun getDownloadRequest(): DownloadManager.Request {
val dlRequest = DownloadManager.Request(uri)
dlRequest.setTitle(filename)
dlRequest.setDescription("Downloading to $localFolderName with filename $filename")
dlRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE)
dlRequest.setDestinationUri(destinationUri)
return dlRequest
}
} }
android/app/src/main/java/com/audiobookshelf/app/plugins/AbsAudioPlayer.kt
+1 -1
View File
@@ -229,7 +229,7 @@ class AbsAudioPlayer : Plugin() {
return call.resolve(JSObject("{\"error\":\"Podcast episode not found\"}")) return call.resolve(JSObject("{\"error\":\"Podcast episode not found\"}"))
} }
} }
if (!it.hasTracks(episode)) { if (!it.hasTracks(mainActivity, episode)) {
return call.resolve(JSObject("{\"error\":\"No audio files found on device. Download book again to fix.\"}")) return call.resolve(JSObject("{\"error\":\"No audio files found on device. Download book again to fix.\"}"))
} }
android/app/src/main/java/com/audiobookshelf/app/plugins/AbsDatabase.kt
+1 -1
View File
@@ -40,7 +40,7 @@ class AbsDatabase : Plugin() {
secureStorage = SecureStorage(mainActivity) secureStorage = SecureStorage(mainActivity)
DeviceManager.dbManager.cleanLocalMediaProgress() DeviceManager.dbManager.cleanLocalMediaProgress()
DeviceManager.dbManager.cleanLocalLibraryItems() DeviceManager.dbManager.cleanLocalLibraryItems(mainActivity)
DeviceManager.dbManager.cleanLogs() DeviceManager.dbManager.cleanLogs()
} }
android/app/src/main/java/com/audiobookshelf/app/plugins/AbsDownloader.kt
+53 -60
View File
@@ -1,17 +1,15 @@
package com.audiobookshelf.app.plugins package com.audiobookshelf.app.plugins
import android.app.DownloadManager
import android.content.Context
import android.os.Environment import android.os.Environment
import android.util.Log import android.util.Log
import com.audiobookshelf.app.MainActivity import com.audiobookshelf.app.MainActivity
import com.audiobookshelf.app.data.* import com.audiobookshelf.app.data.*
import com.audiobookshelf.app.device.DeviceManager import com.audiobookshelf.app.device.DeviceManager
import com.audiobookshelf.app.device.FolderScanner
import com.audiobookshelf.app.models.DownloadItem import com.audiobookshelf.app.models.DownloadItem
import com.audiobookshelf.app.models.DownloadItemPart import com.audiobookshelf.app.models.DownloadItemPart
import com.audiobookshelf.app.server.ApiHandler import com.audiobookshelf.app.server.ApiHandler
import com.audiobookshelf.app.managers.DownloadItemManager import com.audiobookshelf.app.managers.DownloadItemManager
import com.audiobookshelf.app.services.DownloadServiceHost
import com.fasterxml.jackson.core.json.JsonReadFeature import com.fasterxml.jackson.core.json.JsonReadFeature
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.getcapacitor.JSObject import com.getcapacitor.JSObject
@@ -27,9 +25,7 @@ class AbsDownloader : Plugin() {
private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature()) private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
lateinit var mainActivity: MainActivity lateinit var mainActivity: MainActivity
lateinit var downloadManager: DownloadManager
lateinit var apiHandler: ApiHandler lateinit var apiHandler: ApiHandler
lateinit var folderScanner: FolderScanner
lateinit var downloadItemManager: DownloadItemManager lateinit var downloadItemManager: DownloadItemManager
private val clientEventEmitter = (object : DownloadItemManager.DownloadEventEmitter { private val clientEventEmitter = (object : DownloadItemManager.DownloadEventEmitter {
@@ -42,14 +38,44 @@ class AbsDownloader : Plugin() {
override fun onDownloadItemComplete(jsobj:JSObject) { override fun onDownloadItemComplete(jsobj:JSObject) {
notifyListeners("onItemDownloadComplete", jsobj) notifyListeners("onItemDownloadComplete", jsobj)
} }
override fun onQueueChanged(hasWork: Boolean) {
notifyListeners("onQueueChanged", JSObject().put("hasWork", hasWork))
}
}) })
override fun load() { override fun load() {
mainActivity = (activity as MainActivity) mainActivity = (activity as MainActivity)
downloadManager = activity.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
folderScanner = FolderScanner(mainActivity)
apiHandler = ApiHandler(mainActivity) apiHandler = ApiHandler(mainActivity)
downloadItemManager = DownloadItemManager(downloadManager, folderScanner, mainActivity, clientEventEmitter) downloadItemManager = DownloadServiceHost.ensure(mainActivity)
DownloadServiceHost.attachBridge(mainActivity, clientEventEmitter)
}
override fun handleOnDestroy() {
DownloadServiceHost.detachBridge()
super.handleOnDestroy()
}
@PluginMethod
fun setDownloadNotificationStrings(call: PluginCall) {
DownloadServiceHost.setNotificationStrings(
mainActivity,
call.getString("preparing") ?: "Preparing downloads",
call.getString("downloadingFile") ?: "Downloading {0}",
call.getString("waitingForStorage") ?: "Waiting for available storage",
call.getString("downloads") ?: "Downloads",
call.getString("cancel") ?: "Cancel")
call.resolve()
}
/** Replays restored queue items when the frontend subscribes to download events. */
@PluginMethod(returnType = PluginMethod.RETURN_NONE)
override fun addListener(call: PluginCall) {
super.addListener(call)
if (call.getString("eventName") == "onDownloadItem" && ::downloadItemManager.isInitialized) {
downloadItemManager.downloadItemQueue.forEach { item ->
notifyListeners("onDownloadItem", JSObject(jacksonMapper.writeValueAsString(item)))
}
}
} }
@PluginMethod @PluginMethod
@@ -79,7 +105,7 @@ class AbsDownloader : Plugin() {
if (localFolder == null && localFolderId.startsWith("internal-")) { if (localFolder == null && localFolderId.startsWith("internal-")) {
Log.d(tag, "Creating new App Storage internal LocalFolder $localFolderId") Log.d(tag, "Creating new App Storage internal LocalFolder $localFolderId")
localFolder = LocalFolder(localFolderId, "Internal App Storage", "", "", "", "", "internal", libraryItem.mediaType) localFolder = LocalFolder(localFolderId, "Internal App Storage", "", "", "", "internal", libraryItem.mediaType)
DeviceManager.dbManager.saveLocalFolder(localFolder) DeviceManager.dbManager.saveLocalFolder(localFolder)
} }
@@ -132,7 +158,13 @@ class AbsDownloader : Plugin() {
private fun startLibraryItemDownload(libraryItem: LibraryItem, localFolder: LocalFolder, episode:PodcastEpisode?) { private fun startLibraryItemDownload(libraryItem: LibraryItem, localFolder: LocalFolder, episode:PodcastEpisode?) {
val isInternal = localFolder.id.startsWith("internal-") val isInternal = localFolder.id.startsWith("internal-")
val tempFolderPath = if (isInternal) "${mainActivity.filesDir}/downloads/${libraryItem.id}" else mainActivity.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS) val finalInternalFolderPath = "${mainActivity.filesDir}/downloads/${libraryItem.id}"
val tempFolderPath =
if (isInternal) {
"${mainActivity.filesDir}/download-staging/${libraryItem.id}"
} else {
"${mainActivity.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS) ?: mainActivity.filesDir}/download-staging/${libraryItem.id}"
}
Log.d(tag, "downloadCacheDirectory=$tempFolderPath") Log.d(tag, "downloadCacheDirectory=$tempFolderPath")
@@ -143,7 +175,7 @@ class AbsDownloader : Plugin() {
val tracks = libraryItem.media.getAudioTracks() val tracks = libraryItem.media.getAudioTracks()
Log.d(tag, "Starting library item download with ${tracks.size} tracks") Log.d(tag, "Starting library item download with ${tracks.size} tracks")
val itemSubfolder = "$bookAuthor/$bookTitle" val itemSubfolder = "$bookAuthor/$bookTitle"
val itemFolderPath = if (isInternal) "$tempFolderPath" else "${localFolder.absolutePath}/$itemSubfolder" val itemFolderPath = if (isInternal) finalInternalFolderPath else "${localFolder.absolutePath}/$itemSubfolder"
val downloadItem = DownloadItem(libraryItem.id, libraryItem.id, null, libraryItem.userMediaProgress,DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, bookTitle, itemSubfolder, libraryItem.media, mutableListOf()) val downloadItem = DownloadItem(libraryItem.id, libraryItem.id, null, libraryItem.userMediaProgress,DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, bookTitle, itemSubfolder, libraryItem.media, mutableListOf())
val book = libraryItem.media as Book val book = libraryItem.media as Book
@@ -152,17 +184,7 @@ class AbsDownloader : Plugin() {
val serverPath = "/api/items/${libraryItem.id}/file/${ebookFile.ino}/download" val serverPath = "/api/items/${libraryItem.id}/file/${ebookFile.ino}/download"
val destinationFilename = getFilenameFromRelPath(ebookFile.metadata?.relPath ?: "") val destinationFilename = getFilenameFromRelPath(ebookFile.metadata?.relPath ?: "")
val finalDestinationFile = File("$itemFolderPath/$destinationFilename") val finalDestinationFile = File("$itemFolderPath/$destinationFilename")
val destinationFile = File("$tempFolderPath/$destinationFilename") val destinationFile = File("$tempFolderPath/$destinationFilename.part")
if (destinationFile.exists()) {
Log.d(tag, "TEMP ebook file already exists, removing it from ${destinationFile.absolutePath}")
destinationFile.delete()
}
if (finalDestinationFile.exists()) {
Log.d(tag, "ebook file already exists, removing it from ${finalDestinationFile.absolutePath}")
finalDestinationFile.delete()
}
val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,ebookFile,null,null) val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,ebookFile,null,null)
downloadItem.downloadItemParts.add(downloadItemPart) downloadItem.downloadItemParts.add(downloadItemPart)
@@ -181,17 +203,7 @@ class AbsDownloader : Plugin() {
Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename") Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename")
val finalDestinationFile = File("$itemFolderPath/$destinationFilename") val finalDestinationFile = File("$itemFolderPath/$destinationFilename")
val destinationFile = File("$tempFolderPath/$destinationFilename") val destinationFile = File("$tempFolderPath/$destinationFilename.part")
if (destinationFile.exists()) {
Log.d(tag, "TEMP Audio file already exists, removing it from ${destinationFile.absolutePath}")
destinationFile.delete()
}
if (finalDestinationFile.exists()) {
Log.d(tag, "Audio file already exists, removing it from ${finalDestinationFile.absolutePath}")
finalDestinationFile.delete()
}
val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,audioTrack,null) val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,audioTrack,null)
downloadItem.downloadItemParts.add(downloadItemPart) downloadItem.downloadItemParts.add(downloadItemPart)
@@ -205,24 +217,14 @@ class AbsDownloader : Plugin() {
val serverPath = "/api/items/${libraryItem.id}/cover" val serverPath = "/api/items/${libraryItem.id}/cover"
val destinationFilename = "cover-${libraryItem.id}.jpg" val destinationFilename = "cover-${libraryItem.id}.jpg"
val destinationFile = File("$tempFolderPath/$destinationFilename") val destinationFile = File("$tempFolderPath/$destinationFilename.part")
val finalDestinationFile = File("$itemFolderPath/$destinationFilename") val finalDestinationFile = File("$itemFolderPath/$destinationFilename")
if (destinationFile.exists()) {
Log.d(tag, "TEMP Audio file already exists, removing it from ${destinationFile.absolutePath}")
destinationFile.delete()
}
if (finalDestinationFile.exists()) {
Log.d(tag, "Cover already exists, removing it from ${finalDestinationFile.absolutePath}")
finalDestinationFile.delete()
}
val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, coverFileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,null,null) val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, coverFileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,null,null)
downloadItem.downloadItemParts.add(downloadItemPart) downloadItem.downloadItemParts.add(downloadItemPart)
} }
downloadItemManager.addDownloadItem(downloadItem) DownloadServiceHost.enqueue(mainActivity, downloadItem)
} }
} else { } else {
// Podcast episode download // Podcast episode download
@@ -233,7 +235,7 @@ class AbsDownloader : Plugin() {
val fileSize = audioTrack?.metadata?.size ?: 0 val fileSize = audioTrack?.metadata?.size ?: 0
Log.d(tag, "Starting podcast episode download") Log.d(tag, "Starting podcast episode download")
val itemFolderPath = if (isInternal) "$tempFolderPath" else "${localFolder.absolutePath}/$podcastTitle" val itemFolderPath = if (isInternal) finalInternalFolderPath else "${localFolder.absolutePath}/$podcastTitle"
val downloadItemId = "${libraryItem.id}-${episode?.id}" val downloadItemId = "${libraryItem.id}-${episode?.id}"
val downloadItem = DownloadItem(downloadItemId, libraryItem.id, episode?.id, libraryItem.userMediaProgress, DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, podcastTitle, podcastTitle, libraryItem.media, mutableListOf()) val downloadItem = DownloadItem(downloadItemId, libraryItem.id, episode?.id, libraryItem.userMediaProgress, DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, podcastTitle, podcastTitle, libraryItem.media, mutableListOf())
@@ -241,13 +243,8 @@ class AbsDownloader : Plugin() {
var destinationFilename = getFilenameFromRelPath(audioTrack?.relPath ?: "") var destinationFilename = getFilenameFromRelPath(audioTrack?.relPath ?: "")
Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack?.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename") Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack?.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename")
var destinationFile = File("$tempFolderPath/$destinationFilename") var destinationFile = File("$tempFolderPath/$destinationFilename.part")
var finalDestinationFile = File("$itemFolderPath/$destinationFilename") var finalDestinationFile = File("$itemFolderPath/$destinationFilename")
if (finalDestinationFile.exists()) {
Log.d(tag, "Audio file already exists, removing it from ${finalDestinationFile.absolutePath}")
finalDestinationFile.delete()
}
var downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,fileSize, destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,audioTrack,episode) var downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,fileSize, destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,audioTrack,episode)
downloadItem.downloadItemParts.add(downloadItemPart) downloadItem.downloadItemParts.add(downloadItemPart)
@@ -258,18 +255,14 @@ class AbsDownloader : Plugin() {
serverPath = "/api/items/${libraryItem.id}/cover" serverPath = "/api/items/${libraryItem.id}/cover"
destinationFilename = "cover.jpg" destinationFilename = "cover.jpg"
destinationFile = File("$tempFolderPath/$destinationFilename") destinationFile = File("$tempFolderPath/$destinationFilename.part")
finalDestinationFile = File("$itemFolderPath/$destinationFilename") finalDestinationFile = File("$itemFolderPath/$destinationFilename")
if (finalDestinationFile.exists()) { downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,coverFileSize,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,null,null)
Log.d(tag, "Podcast cover already exists - not downloading cover again") downloadItem.downloadItemParts.add(downloadItemPart)
} else {
downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,coverFileSize,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,null,null)
downloadItem.downloadItemParts.add(downloadItemPart)
}
} }
downloadItemManager.addDownloadItem(downloadItem) DownloadServiceHost.enqueue(mainActivity, downloadItem)
} }
} }
} }
android/app/src/main/java/com/audiobookshelf/app/plugins/AbsFileSystem.kt
+145 -86
View File
@@ -1,6 +1,7 @@
package com.audiobookshelf.app.plugins package com.audiobookshelf.app.plugins
import android.app.AlertDialog import android.app.AlertDialog
import android.content.Context
import android.net.Uri import android.net.Uri
import android.os.Build import android.os.Build
import android.util.Log import android.util.Log
@@ -23,40 +24,62 @@ import java.io.File
class AbsFileSystem : Plugin() { class AbsFileSystem : Plugin() {
private val TAG = "AbsFileSystem" private val TAG = "AbsFileSystem"
private val tag = "AbsFileSystem" private val tag = "AbsFileSystem"
private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature()) private var jacksonMapper =
jacksonObjectMapper()
.enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
lateinit var mainActivity: MainActivity lateinit var mainActivity: MainActivity
override fun load() { override fun load() {
mainActivity = (activity as MainActivity) mainActivity = (activity as MainActivity)
mainActivity.storage.storageAccessCallback = object : StorageAccessCallback { mainActivity.storage.storageAccessCallback =
override fun onRootPathNotSelected( object : StorageAccessCallback {
requestCode: Int, override fun onRootPathNotSelected(
rootPath: String, requestCode: Int,
uri: Uri, rootPath: String,
selectedStorageType: StorageType, uri: Uri,
expectedStorageType: StorageType selectedStorageType: StorageType,
) { expectedStorageType: StorageType
Log.d(TAG, "STORAGE ACCESS CALLBACK") ) {
} Log.d(TAG, "STORAGE ACCESS CALLBACK")
}
override fun onCanceledByUser(requestCode: Int) { override fun onCanceledByUser(requestCode: Int) {
Log.d(TAG, "STORAGE ACCESS CALLBACK") Log.d(TAG, "STORAGE ACCESS CALLBACK")
} }
override fun onExpectedStorageNotSelected(requestCode: Int, selectedFolder: DocumentFile, selectedStorageType: StorageType, expectedBasePath: String, expectedStorageType: StorageType) { override fun onExpectedStorageNotSelected(
Log.d(TAG, "STORAGE ACCESS CALLBACK") requestCode: Int,
} selectedFolder: DocumentFile,
selectedStorageType: StorageType,
expectedBasePath: String,
expectedStorageType: StorageType
) {
Log.d(TAG, "STORAGE ACCESS CALLBACK")
}
override fun onStoragePermissionDenied(requestCode: Int) { override fun onStoragePermissionDenied(requestCode: Int) {
Log.d(TAG, "STORAGE ACCESS CALLBACK") Log.d(TAG, "STORAGE ACCESS CALLBACK")
} }
override fun onRootPathPermissionGranted(requestCode: Int, root: DocumentFile) { override fun onRootPathPermissionGranted(requestCode: Int, root: DocumentFile) {
Log.d(TAG, "STORAGE ACCESS CALLBACK") Log.d(TAG, "STORAGE ACCESS CALLBACK")
} }
} }
}
@PluginMethod
fun setFolderPickerStrings(call: PluginCall) {
mainActivity.getSharedPreferences(FOLDER_PICKER_PREFERENCES, Context.MODE_PRIVATE)
.edit()
.putString(KEY_WRITE_ACCESS_REQUIRED, call.getString("writeAccessRequired"))
.putString(KEY_ALLOW, call.getString("allow"))
.putString(KEY_CANCEL, call.getString("cancel"))
.putString(KEY_ACCESS_DENIED, call.getString("accessDenied"))
.putString(KEY_PERMISSION_DENIED, call.getString("permissionDenied"))
.apply()
call.resolve()
} }
@PluginMethod @PluginMethod
@@ -65,60 +88,74 @@ class AbsFileSystem : Plugin() {
val REQUEST_CODE_SELECT_FOLDER = 6 val REQUEST_CODE_SELECT_FOLDER = 6
val REQUEST_CODE_SDCARD_ACCESS = 7 val REQUEST_CODE_SDCARD_ACCESS = 7
mainActivity.storage.folderPickerCallback = object : FolderPickerCallback { mainActivity.storage.folderPickerCallback =
override fun onFolderSelected(requestCode: Int, folder: DocumentFile) { object : FolderPickerCallback {
Log.d(TAG, "ON FOLDER SELECTED ${folder.uri} ${folder.name}") override fun onFolderSelected(requestCode: Int, folder: DocumentFile) {
val absolutePath = folder.getAbsolutePath(activity) Log.d(TAG, "ON FOLDER SELECTED ${folder.uri} ${folder.name}")
val storageType = folder.getStorageType(activity) val absolutePath = folder.getAbsolutePath(activity)
val simplePath = folder.getSimplePath(activity) val storageType = folder.getStorageType(activity)
val basePath = folder.getBasePath(activity) val basePath = folder.getBasePath(activity)
val folderId = android.util.Base64.encodeToString(folder.id.toByteArray(), android.util.Base64.DEFAULT) val folderId =
android.util.Base64.encodeToString(
folder.id.toByteArray(),
android.util.Base64.DEFAULT
)
val localFolder = LocalFolder(folderId, folder.name ?: "", folder.uri.toString(),basePath,absolutePath, simplePath, storageType.toString(), mediaType) val localFolder =
LocalFolder(
folderId,
folder.name ?: "",
folder.uri.toString(),
basePath,
absolutePath,
storageType.toString(),
mediaType
)
DeviceManager.dbManager.saveLocalFolder(localFolder) DeviceManager.dbManager.saveLocalFolder(localFolder)
call.resolve(JSObject(jacksonMapper.writeValueAsString(localFolder))) call.resolve(JSObject(jacksonMapper.writeValueAsString(localFolder)))
} }
override fun onStorageAccessDenied( override fun onStorageAccessDenied(
requestCode: Int, requestCode: Int,
folder: DocumentFile?, folder: DocumentFile?,
storageType: StorageType, storageType: StorageType,
storageId: String storageId: String
) { ) {
Log.e(tag, "Storage Access Denied ${folder?.getAbsolutePath(mainActivity)}") Log.e(tag, "Storage Access Denied ${folder?.getAbsolutePath(mainActivity)}")
val jsobj = JSObject() val jsobj = JSObject()
if (requestCode == REQUEST_CODE_SELECT_FOLDER) { if (requestCode == REQUEST_CODE_SELECT_FOLDER) {
val builder: AlertDialog.Builder = AlertDialog.Builder(mainActivity) val builder: AlertDialog.Builder = AlertDialog.Builder(mainActivity)
builder.setMessage( builder.setMessage(folderPickerString(KEY_WRITE_ACCESS_REQUIRED, DEFAULT_WRITE_ACCESS_REQUIRED))
"You have no write access to this storage, thus selecting this folder is useless." + builder.setNegativeButton(folderPickerString(KEY_CANCEL, DEFAULT_CANCEL)) { _, _ ->
"\nWould you like to grant access to this folder?") run {
builder.setNegativeButton("Dont Allow") { _, _ -> jsobj.put("error", folderPickerString(KEY_ACCESS_DENIED, DEFAULT_ACCESS_DENIED))
run { call.resolve(jsobj)
jsobj.put("error", "User Canceled, Access Denied") }
call.resolve(jsobj) }
builder.setPositiveButton(folderPickerString(KEY_ALLOW, DEFAULT_ALLOW)) { _, _ ->
mainActivity.storageHelper.requestStorageAccess(
REQUEST_CODE_SDCARD_ACCESS,
initialPath = FileFullPath(mainActivity, storageId, "")
)
}
builder.show()
} else {
Log.d(TAG, "STORAGE ACCESS DENIED $requestCode")
jsobj.put("error", folderPickerString(KEY_ACCESS_DENIED, DEFAULT_ACCESS_DENIED))
call.resolve(jsobj)
}
}
override fun onStoragePermissionDenied(requestCode: Int) {
Log.d(TAG, "STORAGE PERMISSION DENIED $requestCode")
val jsobj = JSObject()
jsobj.put("error", folderPickerString(KEY_PERMISSION_DENIED, DEFAULT_PERMISSION_DENIED))
call.resolve(jsobj)
}
} }
}
builder.setPositiveButton("Allow.") { _, _ -> mainActivity.storageHelper.requestStorageAccess(REQUEST_CODE_SDCARD_ACCESS, initialPath = FileFullPath(mainActivity, storageId, "")) }
builder.show()
} else {
Log.d(TAG, "STORAGE ACCESS DENIED $requestCode")
jsobj.put("error", "Access Denied")
call.resolve(jsobj)
}
}
override fun onStoragePermissionDenied(requestCode: Int) {
Log.d(TAG, "STORAGE PERMISSION DENIED $requestCode")
val jsobj = JSObject()
jsobj.put("error", "Permission Denied")
call.resolve(jsobj)
}
}
mainActivity.storage.openFolderPicker(REQUEST_CODE_SELECT_FOLDER) mainActivity.storage.openFolderPicker(REQUEST_CODE_SELECT_FOLDER)
} }
@@ -152,7 +189,7 @@ class AbsFileSystem : Plugin() {
val folderUrl = call.data.getString("folderUrl", "").toString() val folderUrl = call.data.getString("folderUrl", "").toString()
Log.d(TAG, "Check Folder Permissions for $folderUrl") Log.d(TAG, "Check Folder Permissions for $folderUrl")
val hasAccess = SimpleStorage.hasStorageAccess(context,folderUrl,true) val hasAccess = SimpleStorage.hasStorageAccess(context, folderUrl, true)
val jsobj = JSObject() val jsobj = JSObject()
jsobj.put("value", hasAccess) jsobj.put("value", hasAccess)
@@ -196,26 +233,29 @@ class AbsFileSystem : Plugin() {
if (localLibraryItem?.folderId?.startsWith("internal-") == true) { if (localLibraryItem?.folderId?.startsWith("internal-") == true) {
Log.d(tag, "Deleting internal library item at absolutePath $absolutePath") Log.d(tag, "Deleting internal library item at absolutePath $absolutePath")
val file = File(absolutePath) val file = File(absolutePath)
success = if (file.exists()) { success =
file.deleteRecursively() if (file.exists()) {
} else { file.deleteRecursively()
true } else {
} true
}
} else { } else {
var subfolderPathToDelete = "" var subfolderPathToDelete = ""
localLibraryItem?.folderId?.let { folderId -> localLibraryItem?.folderId?.let { folderId ->
val folder = DeviceManager.dbManager.getLocalFolder(folderId) val folder = DeviceManager.dbManager.getLocalFolder(folderId)
folder?.absolutePath?.let { folderPath -> folder?.absolutePath?.let { folderPath ->
val splitAbsolutePath = absolutePath.split("/") val splitAbsolutePath = absolutePath.split("/")
val fullSubDir = splitAbsolutePath.subList(0, splitAbsolutePath.size - 1).joinToString("/") val fullSubDir =
splitAbsolutePath.subList(0, splitAbsolutePath.size - 1).joinToString("/")
if (fullSubDir != folderPath) { if (fullSubDir != folderPath) {
val subdirHasAnItem = DeviceManager.dbManager.getLocalLibraryItems().any { _localLibraryItem -> val subdirHasAnItem =
if (_localLibraryItem.id == localLibraryItemId) { DeviceManager.dbManager.getLocalLibraryItems().any { _localLibraryItem ->
false if (_localLibraryItem.id == localLibraryItemId) {
} else { false
_localLibraryItem.absolutePath.startsWith(fullSubDir) } else {
} _localLibraryItem.absolutePath.startsWith(fullSubDir)
} }
}
subfolderPathToDelete = if (subdirHasAnItem) "" else fullSubDir subfolderPathToDelete = if (subdirHasAnItem) "" else fullSubDir
} }
} }
@@ -266,4 +306,23 @@ class AbsFileSystem : Plugin() {
call.resolve(JSObject("{\"success\":false}")) call.resolve(JSObject("{\"success\":false}"))
} }
} }
private fun folderPickerString(key: String, defaultValue: String): String =
mainActivity.getSharedPreferences(FOLDER_PICKER_PREFERENCES, Context.MODE_PRIVATE)
.getString(key, defaultValue) ?: defaultValue
private companion object {
const val FOLDER_PICKER_PREFERENCES = "folder_picker"
const val KEY_WRITE_ACCESS_REQUIRED = "write_access_required"
const val KEY_ALLOW = "allow"
const val KEY_CANCEL = "cancel"
const val KEY_ACCESS_DENIED = "access_denied"
const val KEY_PERMISSION_DENIED = "permission_denied"
const val DEFAULT_WRITE_ACCESS_REQUIRED =
"You do not have write access to this folder. Would you like to grant access?"
const val DEFAULT_ALLOW = "Allow"
const val DEFAULT_CANCEL = "Cancel"
const val DEFAULT_ACCESS_DENIED = "Access denied"
const val DEFAULT_PERMISSION_DENIED = "Permission denied"
}
} }
android/app/src/main/java/com/audiobookshelf/app/services/DownloadService.kt
+102
View File
@@ -0,0 +1,102 @@
package com.audiobookshelf.app.services
import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Context
import android.content.Intent
import android.content.pm.ServiceInfo
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationCompat
import com.audiobookshelf.app.R
import com.audiobookshelf.app.models.DownloadItemPart
/** Android-owned foreground lifecycle for transfers that must outlive the WebView and Activity. */
class DownloadService : Service() {
override fun onCreate() {
super.onCreate()
createChannel()
startForegroundWithType(DownloadServiceHost.notificationStrings(this).preparing)
DownloadServiceHost.attachService(this)
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
when (intent?.action) {
ACTION_CANCEL -> DownloadServiceHost.cancelAll(this)
else -> {
startForegroundWithType(DownloadServiceHost.notificationStrings(this).preparing)
DownloadServiceHost.ensure(this)
}
}
return START_STICKY
}
override fun onDestroy() {
DownloadServiceHost.detachService(this)
super.onDestroy()
}
override fun onBind(intent: Intent?): IBinder? = null
fun onPartUpdate(part: DownloadItemPart) {
val strings = DownloadServiceHost.notificationStrings(this)
val text =
if (part.waitingForSpace) strings.waitingForStorage
else strings.downloadingFile.replace("{0}", part.filename)
val progress = part.progress.coerceIn(0L, 100L).toInt()
val notification = notification(text, progress, part.fileSize > 0L)
(getSystemService(NOTIFICATION_SERVICE) as NotificationManager).notify(NOTIFICATION_ID, notification)
}
fun onQueueChanged(hasWork: Boolean) {
if (!hasWork) {
stopForeground(STOP_FOREGROUND_REMOVE)
stopSelf()
}
}
private fun startForegroundWithType(text: String) {
val notification = notification(text)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
} else {
startForeground(NOTIFICATION_ID, notification)
}
}
private fun notification(text: String, progress: Int = 0, determinate: Boolean = false): Notification {
val cancelIntent = PendingIntent.getService(
this, 1, Intent(this, DownloadService::class.java).setAction(ACTION_CANCEL), pendingIntentFlags())
return NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.icon)
.setContentTitle(DownloadServiceHost.notificationStrings(this).downloads)
.setContentText(text)
.setOnlyAlertOnce(true)
.setOngoing(true)
.setProgress(100, progress, !determinate)
.addAction(0, DownloadServiceHost.notificationStrings(this).cancel, cancelIntent)
.build()
}
private fun createChannel() {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
val manager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
manager.createNotificationChannel(
NotificationChannel(
CHANNEL_ID,
DownloadServiceHost.notificationStrings(this).downloads,
NotificationManager.IMPORTANCE_LOW))
}
private fun pendingIntentFlags(): Int = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
companion object {
private const val CHANNEL_ID = "downloads"
private const val NOTIFICATION_ID = 11
private const val ACTION_CANCEL = "com.audiobookshelf.app.download.CANCEL"
fun intent(context: Context) = Intent(context, DownloadService::class.java)
}
}
android/app/src/main/java/com/audiobookshelf/app/services/DownloadServiceHost.kt
+147
View File
@@ -0,0 +1,147 @@
package com.audiobookshelf.app.services
import android.content.Context
import androidx.core.content.ContextCompat
import com.audiobookshelf.app.device.FolderScanner
import com.audiobookshelf.app.managers.DbManager
import com.audiobookshelf.app.managers.DownloadItemManager
import com.audiobookshelf.app.models.DownloadItem
import com.getcapacitor.JSObject
import java.util.Collections
/** Shared process owner used by the foreground service and the Capacitor bridge. */
object DownloadServiceHost {
data class NotificationStrings(
val preparing: String,
val downloadingFile: String,
val waitingForStorage: String,
val downloads: String,
val cancel: String
)
private var manager: DownloadItemManager? = null
private var bridgeEmitter: DownloadItemManager.DownloadEventEmitter = NoopEmitter
private var service: DownloadService? = null
@Volatile private var bridgeReady = false
private val deferredCompletions = Collections.synchronizedList(mutableListOf<JSObject>())
@Synchronized
fun ensure(context: Context): DownloadItemManager {
if (manager == null) {
val appContext = context.applicationContext
DbManager.initialize(appContext)
manager = DownloadItemManager(FolderScanner(appContext), appContext, ForwardingEmitter)
manager!!.restoreQueue()
}
return manager!!
}
/** Attaches the frontend after restored queue items have been emitted. */
@Synchronized
fun attachBridge(context: Context, emitter: DownloadItemManager.DownloadEventEmitter) {
bridgeReady = false
bridgeEmitter = emitter
val queue = ensure(context)
queue.setEventEmitter(ForwardingEmitter)
bridgeReady = true
val completions = synchronized(deferredCompletions) {
deferredCompletions.toList().also { deferredCompletions.clear() }
}
completions.forEach(bridgeEmitter::onDownloadItemComplete)
if (queue.hasWork()) startService(context)
}
@Synchronized
fun detachBridge() {
bridgeReady = false
bridgeEmitter = NoopEmitter
}
@Synchronized
fun enqueue(context: Context, item: DownloadItem) {
ensure(context).addDownloadItem(item)
startService(context)
}
@Synchronized
fun cancelAll(context: Context) { ensure(context).cancelAll() }
fun setNotificationStrings(
context: Context,
preparing: String,
downloadingFile: String,
waitingForStorage: String,
downloads: String,
cancel: String
) {
context.getSharedPreferences(NOTIFICATION_PREFERENCES, Context.MODE_PRIVATE)
.edit()
.putString(KEY_PREPARING, preparing)
.putString(KEY_DOWNLOADING_FILE, downloadingFile)
.putString(KEY_WAITING_FOR_STORAGE, waitingForStorage)
.putString(KEY_DOWNLOADS, downloads)
.putString(KEY_CANCEL, cancel)
.apply()
}
fun notificationStrings(context: Context): NotificationStrings {
val preferences = context.getSharedPreferences(NOTIFICATION_PREFERENCES, Context.MODE_PRIVATE)
return NotificationStrings(
preferences.getString(KEY_PREPARING, DEFAULT_PREPARING) ?: DEFAULT_PREPARING,
preferences.getString(KEY_DOWNLOADING_FILE, DEFAULT_DOWNLOADING_FILE)
?: DEFAULT_DOWNLOADING_FILE,
preferences.getString(KEY_WAITING_FOR_STORAGE, DEFAULT_WAITING_FOR_STORAGE)
?: DEFAULT_WAITING_FOR_STORAGE,
preferences.getString(KEY_DOWNLOADS, DEFAULT_DOWNLOADS) ?: DEFAULT_DOWNLOADS,
preferences.getString(KEY_CANCEL, DEFAULT_CANCEL) ?: DEFAULT_CANCEL)
}
@Synchronized
fun attachService(downloadService: DownloadService) {
service = downloadService
service?.onQueueChanged(ensure(downloadService).hasWork())
}
@Synchronized
fun detachService(downloadService: DownloadService) {
if (service === downloadService) service = null
}
private fun startService(context: Context) {
ContextCompat.startForegroundService(context, DownloadService.intent(context))
}
private object ForwardingEmitter : DownloadItemManager.DownloadEventEmitter {
override fun onDownloadItem(downloadItem: DownloadItem) { bridgeEmitter.onDownloadItem(downloadItem) }
override fun onDownloadItemPartUpdate(downloadItemPart: com.audiobookshelf.app.models.DownloadItemPart) {
if (bridgeReady) bridgeEmitter.onDownloadItemPartUpdate(downloadItemPart)
service?.onPartUpdate(downloadItemPart)
}
override fun onDownloadItemComplete(jsobj: JSObject) {
if (bridgeReady) bridgeEmitter.onDownloadItemComplete(jsobj) else deferredCompletions.add(jsobj)
}
override fun onQueueChanged(hasWork: Boolean) {
bridgeEmitter.onQueueChanged(hasWork)
service?.onQueueChanged(hasWork)
}
}
private object NoopEmitter : DownloadItemManager.DownloadEventEmitter {
override fun onDownloadItem(downloadItem: DownloadItem) = Unit
override fun onDownloadItemPartUpdate(downloadItemPart: com.audiobookshelf.app.models.DownloadItemPart) = Unit
override fun onDownloadItemComplete(jsobj: JSObject) = Unit
override fun onQueueChanged(hasWork: Boolean) = Unit
}
private const val NOTIFICATION_PREFERENCES = "download_notifications"
private const val KEY_PREPARING = "preparing"
private const val KEY_DOWNLOADING_FILE = "downloading_file"
private const val KEY_WAITING_FOR_STORAGE = "waiting_for_storage"
private const val KEY_DOWNLOADS = "downloads"
private const val KEY_CANCEL = "cancel"
private const val DEFAULT_PREPARING = "Preparing downloads"
private const val DEFAULT_DOWNLOADING_FILE = "Downloading {0}"
private const val DEFAULT_WAITING_FOR_STORAGE = "Waiting for available storage"
private const val DEFAULT_DOWNLOADS = "Downloads"
private const val DEFAULT_CANCEL = "Cancel"
}
components/widgets/DownloadProgressIndicator.vue
+7 -1
View File
@@ -12,7 +12,8 @@ export default {
return { return {
downloadItemListener: null, downloadItemListener: null,
completeListener: null, completeListener: null,
itemPartUpdateListener: null itemPartUpdateListener: null,
queueChangedListener: null
} }
}, },
computed: { computed: {
@@ -76,17 +77,22 @@ export default {
}, },
onDownloadItemPartUpdate(itemPart) { onDownloadItemPartUpdate(itemPart) {
this.$store.commit('globals/updateDownloadItemPart', itemPart) this.$store.commit('globals/updateDownloadItemPart', itemPart)
},
onQueueChanged(data) {
if (!data.hasWork) this.$store.commit('globals/clearItemDownloads')
} }
}, },
async mounted() { async mounted() {
this.downloadItemListener = await AbsDownloader.addListener('onDownloadItem', (data) => this.onDownloadItem(data)) this.downloadItemListener = await AbsDownloader.addListener('onDownloadItem', (data) => this.onDownloadItem(data))
this.itemPartUpdateListener = await AbsDownloader.addListener('onDownloadItemPartUpdate', (data) => this.onDownloadItemPartUpdate(data)) this.itemPartUpdateListener = await AbsDownloader.addListener('onDownloadItemPartUpdate', (data) => this.onDownloadItemPartUpdate(data))
this.queueChangedListener = await AbsDownloader.addListener('onQueueChanged', (data) => this.onQueueChanged(data))
this.completeListener = await AbsDownloader.addListener('onItemDownloadComplete', (data) => this.onItemDownloadComplete(data)) this.completeListener = await AbsDownloader.addListener('onItemDownloadComplete', (data) => this.onItemDownloadComplete(data))
}, },
beforeDestroy() { beforeDestroy() {
this.downloadItemListener?.remove() this.downloadItemListener?.remove()
this.completeListener?.remove() this.completeListener?.remove()
this.itemPartUpdateListener?.remove() this.itemPartUpdateListener?.remove()
this.queueChangedListener?.remove()
} }
} }
</script> </script>
plugins/capacitor/AbsDatabase.js
-2
View File
@@ -119,7 +119,6 @@ class AbsDatabaseWeb extends WebPlugin {
name: 'Audiobooks', name: 'Audiobooks',
contentUrl: 'test', contentUrl: 'test',
absolutePath: '/audiobooks', absolutePath: '/audiobooks',
simplePath: 'audiobooks',
storageType: 'primary', storageType: 'primary',
mediaType: 'book' mediaType: 'book'
} }
@@ -196,7 +195,6 @@ class AbsDatabaseWeb extends WebPlugin {
filename: 'lf1.mp3', filename: 'lf1.mp3',
contentUrl: 'test', contentUrl: 'test',
absolutePath: 'test', absolutePath: 'test',
simplePath: 'test',
mimeType: 'audio/mpeg', mimeType: 'audio/mpeg',
size: 39048290 size: 39048290
} }
plugins/i18n.js
+22 -1
View File
@@ -1,4 +1,6 @@
import Vue from 'vue' import Vue from 'vue'
import { Capacitor } from '@capacitor/core'
import { AbsDownloader, AbsFileSystem } from '@/plugins/capacitor'
import enUsStrings from '../strings/en-us.json' import enUsStrings from '../strings/en-us.json'
const defaultCode = 'en-us' const defaultCode = 'en-us'
@@ -41,6 +43,24 @@ function supplant(str, subs) {
}) })
} }
function syncDownloadNotificationStrings() {
if (Capacitor.getPlatform() !== 'android') return
AbsDownloader.setDownloadNotificationStrings({
preparing: Vue.prototype.$strings.MessagePreparingDownloads,
downloadingFile: Vue.prototype.$strings.MessageDownloadingFile,
waitingForStorage: Vue.prototype.$strings.MessageWaitingForAvailableStorage,
downloads: Vue.prototype.$strings.HeaderDownloads,
cancel: Vue.prototype.$strings.ButtonCancel
}).catch((error) => console.warn('Failed to update download notification strings', error))
AbsFileSystem.setFolderPickerStrings({
writeAccessRequired: Vue.prototype.$strings.MessageStorageWriteAccessRequired,
allow: Vue.prototype.$strings.ButtonAllow,
cancel: Vue.prototype.$strings.ButtonCancel,
accessDenied: Vue.prototype.$strings.MessageStorageAccessDenied,
permissionDenied: Vue.prototype.$strings.MessageStoragePermissionDenied
}).catch((error) => console.warn('Failed to update folder picker strings', error))
}
Vue.prototype.$languageCodeOptions = Object.keys(languageCodeMap).map((code) => { Vue.prototype.$languageCodeOptions = Object.keys(languageCodeMap).map((code) => {
return { return {
text: languageCodeMap[code].label, text: languageCodeMap[code].label,
@@ -108,6 +128,7 @@ async function loadi18n(code) {
} }
Vue.prototype.$setDateFnsLocale(languageCodeMap[code].dateFnsLocale) Vue.prototype.$setDateFnsLocale(languageCodeMap[code].dateFnsLocale)
syncDownloadNotificationStrings()
this.$eventBus.$emit('change-lang', code) this.$eventBus.$emit('change-lang', code)
return true return true
@@ -145,5 +166,5 @@ async function initialize() {
export default ({ app, store }, inject) => { export default ({ app, store }, inject) => {
$localStore = app.$localStore $localStore = app.$localStore
initialize() initialize().finally(syncDownloadNotificationStrings)
} }
store/globals.js
+3
View File
@@ -135,6 +135,9 @@ export const mutations = {
removeItemDownload(state, id) { removeItemDownload(state, id) {
state.itemDownloads = state.itemDownloads.filter((i) => i.id != id) state.itemDownloads = state.itemDownloads.filter((i) => i.id != id)
}, },
clearItemDownloads(state) {
state.itemDownloads = []
},
setBookshelfListView(state, val) { setBookshelfListView(state, val) {
state.bookshelfListView = val state.bookshelfListView = val
}, },
strings/en-us.json
+9 -2
View File
@@ -1,6 +1,7 @@
{ {
"ButtonAdd": "Add", "ButtonAdd": "Add",
"ButtonAddNewServer": "Add New Server", "ButtonAddNewServer": "Add New Server",
"ButtonAllow": "Allow",
"ButtonAuthors": "Authors", "ButtonAuthors": "Authors",
"ButtonBack": "Back", "ButtonBack": "Back",
"ButtonCancel": "Cancel", "ButtonCancel": "Cancel",
@@ -295,7 +296,7 @@
"MessageAudiobookshelfServerNotConnected": "Audiobookshelf server not connected", "MessageAudiobookshelfServerNotConnected": "Audiobookshelf server not connected",
"MessageAudiobookshelfServerRequired": "<strong>Important!</strong> This app is designed to work with an Audiobookshelf server that you or someone you know is hosting. This app does not provide any content.", "MessageAudiobookshelfServerRequired": "<strong>Important!</strong> This app is designed to work with an Audiobookshelf server that you or someone you know is hosting. This app does not provide any content.",
"MessageBookshelfEmpty": "Bookshelf empty", "MessageBookshelfEmpty": "Bookshelf empty",
"MessageConfirmAppExit":"Did you want to exit the app?", "MessageConfirmAppExit": "Did you want to exit the app?",
"MessageConfirmDeleteEpisodeDownloadQueue": "Are you sure you want to clear episode download queue?", "MessageConfirmDeleteEpisodeDownloadQueue": "Are you sure you want to clear episode download queue?",
"MessageConfirmDeleteLocalEpisode": "Remove local episode \"{0}\" from your device? The file on the server will be unaffected.", "MessageConfirmDeleteLocalEpisode": "Remove local episode \"{0}\" from your device? The file on the server will be unaffected.",
"MessageConfirmDeleteLocalFiles": "Remove local files of this item from your device? The files on the server and your progress will be unaffected.", "MessageConfirmDeleteLocalFiles": "Remove local files of this item from your device? The files on the server and your progress will be unaffected.",
@@ -305,13 +306,14 @@
"MessageConfirmDiscardProgress": "Are you sure you want to reset your progress?", "MessageConfirmDiscardProgress": "Are you sure you want to reset your progress?",
"MessageConfirmDownloadUsingCellular": "You are about to download using cellular data. This may include carrier data charges. Do you wish to continue?", "MessageConfirmDownloadUsingCellular": "You are about to download using cellular data. This may include carrier data charges. Do you wish to continue?",
"MessageConfirmMarkAsFinished": "Are you sure you want to mark this item as finished?", "MessageConfirmMarkAsFinished": "Are you sure you want to mark this item as finished?",
"MessageConfirmPlaybackTime":"Start playback for \"{0}\" at {1}?", "MessageConfirmPlaybackTime": "Start playback for \"{0}\" at {1}?",
"MessageConfirmRemoveBookmark": "Are you sure you want to remove bookmark?", "MessageConfirmRemoveBookmark": "Are you sure you want to remove bookmark?",
"MessageConfirmStreamingUsingCellular": "You are about to stream using cellular data. This may include carrier data charges. Do you wish to continue?", "MessageConfirmStreamingUsingCellular": "You are about to stream using cellular data. This may include carrier data charges. Do you wish to continue?",
"MessageDiscardProgress": "Discard Progress", "MessageDiscardProgress": "Discard Progress",
"MessageDownloadCompleteProcessing": "Download complete. Processing...", "MessageDownloadCompleteProcessing": "Download complete. Processing...",
"MessageDownloading": "Downloading...", "MessageDownloading": "Downloading...",
"MessageDownloadingEpisode": "Downloading episode", "MessageDownloadingEpisode": "Downloading episode",
"MessageDownloadingFile": "Downloading {0}",
"MessageEpisodesQueuedForDownload": "{0} Episode(s) queued for download", "MessageEpisodesQueuedForDownload": "{0} Episode(s) queued for download",
"MessageFailedToRefreshToken": "Failed to refresh token, re-login required", "MessageFailedToRefreshToken": "Failed to refresh token, re-login required",
"MessageFeedURLWillBe": "Feed URL will be {0}", "MessageFeedURLWillBe": "Feed URL will be {0}",
@@ -347,6 +349,7 @@
"MessageOldServerConnectionWarning": "Server connection config is using an old user ID. Please delete and re-add this server connection.", "MessageOldServerConnectionWarning": "Server connection config is using an old user ID. Please delete and re-add this server connection.",
"MessageOldServerConnectionWarningHelp": "You originally set up the connection to this server prior to the database migration in 2.3.0, released June 2023. A future server update will remove the ability to sign in with this old connection. Please delete the existing server connection and connect again (using the same server address and credentials). If you have any downloaded media on this device, the media will need to be downloaded again to sync with the server.", "MessageOldServerConnectionWarningHelp": "You originally set up the connection to this server prior to the database migration in 2.3.0, released June 2023. A future server update will remove the ability to sign in with this old connection. Please delete the existing server connection and connect again (using the same server address and credentials). If you have any downloaded media on this device, the media will need to be downloaded again to sync with the server.",
"MessagePodcastSearchField": "Enter search term or RSS feed URL", "MessagePodcastSearchField": "Enter search term or RSS feed URL",
"MessagePreparingDownloads": "Preparing downloads",
"MessageProgressSyncFailed": "The most recent attempt to report your listening progress to the server has failed. Progress sync requests will continue to be attempted every 15 seconds to 1 minute while media is playing.", "MessageProgressSyncFailed": "The most recent attempt to report your listening progress to the server has failed. Progress sync requests will continue to be attempted every 15 seconds to 1 minute while media is playing.",
"MessageReportBugsAndContribute": "Report bugs, request features, and contribute on", "MessageReportBugsAndContribute": "Report bugs, request features, and contribute on",
"MessageSeriesAlreadyDownloaded": "You have already downloaded all books in this series.", "MessageSeriesAlreadyDownloaded": "You have already downloaded all books in this series.",
@@ -357,6 +360,10 @@
"MessageSocketConnectedOverUnmeteredCellular": "Socket connected over unmetered cellular", "MessageSocketConnectedOverUnmeteredCellular": "Socket connected over unmetered cellular",
"MessageSocketConnectedOverUnmeteredWifi": "Socket connected over unmetered wifi", "MessageSocketConnectedOverUnmeteredWifi": "Socket connected over unmetered wifi",
"MessageSocketNotConnected": "Socket not connected", "MessageSocketNotConnected": "Socket not connected",
"MessageStorageAccessDenied": "Access denied",
"MessageStoragePermissionDenied": "Permission denied",
"MessageStorageWriteAccessRequired": "You do not have write access to this folder. Would you like to grant access?",
"MessageWaitingForAvailableStorage": "Waiting for available storage",
"NoteRSSFeedPodcastAppsHttps": "Warning: Most podcast apps will require the RSS feed URL is using HTTPS", "NoteRSSFeedPodcastAppsHttps": "Warning: Most podcast apps will require the RSS feed URL is using HTTPS",
"NoteRSSFeedPodcastAppsPubDate": "Warning: 1 or more of your episodes do not have a Pub Date. Some podcast apps require this.", "NoteRSSFeedPodcastAppsPubDate": "Warning: 1 or more of your episodes do not have a Pub Date. Some podcast apps require this.",
"ToastBookmarkCreateFailed": "Failed to create bookmark", "ToastBookmarkCreateFailed": "Failed to create bookmark",