Fix crash when server requests fail

android/app/src/main/java/com/audiobookshelf/app/media/MediaManager.kt

@@ -270,17 +270,21 @@ class MediaManager(var apiHandler: ApiHandler, var ctx: Context) {
     }
   }
 
-  fun play(libraryItemWrapper:LibraryItemWrapper, episode:PodcastEpisode?, playItemRequestPayload:PlayItemRequestPayload, cb: (PlaybackSession) -> Unit) {
+  fun play(libraryItemWrapper:LibraryItemWrapper, episode:PodcastEpisode?, playItemRequestPayload:PlayItemRequestPayload, cb: (PlaybackSession?) -> Unit) {
    if (libraryItemWrapper is LocalLibraryItem) {
     val localLibraryItem = libraryItemWrapper as LocalLibraryItem
     cb(localLibraryItem.getPlaybackSession(episode))
    } else {
      val libraryItem = libraryItemWrapper as LibraryItem
      apiHandler.playLibraryItem(libraryItem.id,episode?.id ?: "",playItemRequestPayload) {
+       if (it == null) {
+         cb(null)
+       } else {
          cb(it)
        }
      }
    }
+  }
 
   private fun levenshtein(lhs : CharSequence, rhs : CharSequence) : Int {
     val lhsLength = lhs.length + 1

android/app/src/main/java/com/audiobookshelf/app/player/MediaSessionCallback.kt

@@ -25,13 +25,16 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
     Log.d(tag, "ON PREPARE MEDIA SESSION COMPAT")
     playerNotificationService.mediaManager.getFirstItem()?.let { li ->
       playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
+        if (it == null) {
+          Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
             playerNotificationService.preparePlayer(it,true,null)
           }
         }
       }
     }
+  }
 
   override fun onPlay() {
     Log.d(tag, "ON PLAY MEDIA SESSION COMPAT")
@@ -47,9 +50,12 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
     Log.d(tag, "ON PLAY FROM SEARCH $query")
     playerNotificationService.mediaManager.getFromSearch(query)?.let { li ->
       playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
+        if (it == null) {
+           Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,true,null)
+            playerNotificationService.preparePlayer(it, true, null)
+          }
         }
       }
     }
@@ -105,9 +111,12 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
 
     libraryItemWrapper?.let { li ->
       playerNotificationService.mediaManager.play(li, podcastEpisode, playerNotificationService.getPlayItemRequestPayload(false)) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,true,null)
+            playerNotificationService.preparePlayer(it, true, null)
+          }
         }
       }
     }

android/app/src/main/java/com/audiobookshelf/app/player/MediaSessionPlaybackPreparer.kt

@@ -31,8 +31,12 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
     Log.d(tag, "ON PREPARE $playWhenReady")
     playerNotificationService.mediaManager.getFirstItem()?.let { li ->
       playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+          Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+            playerNotificationService.preparePlayer(it, playWhenReady, null)
+          }
         }
       }
     }
@@ -54,9 +58,12 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
 
     libraryItemWrapper?.let { li ->
       playerNotificationService.mediaManager.play(li, podcastEpisode, playerNotificationService.getPlayItemRequestPayload(false)) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+            playerNotificationService.preparePlayer(it, playWhenReady, null)
+          }
         }
       }
     }
@@ -66,9 +73,12 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
     Log.d(tag, "ON PREPARE FROM SEARCH $query")
     playerNotificationService.mediaManager.getFromSearch(query)?.let { li ->
       playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
           Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+            playerNotificationService.preparePlayer(it, playWhenReady, null)
+          }
         }
       }
     }

android/app/src/main/java/com/audiobookshelf/app/player/PlayerNotificationService.kt

@@ -381,10 +381,15 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
         val libraryItemId = playbackSession.libraryItemId ?: "" // Must be true since direct play
         val episodeId = playbackSession.episodeId
         apiHandler.playLibraryItem(libraryItemId, episodeId, playItemRequestPayload) {
+          if (it == null) { // Play request failed
+            clientEventEmitter?.onPlaybackFailed(errorMessage)
+            closePlayback()
+          } else {
             Handler(Looper.getMainLooper()).post {
               preparePlayer(it, true, null)
             }
           }
+        }
       } else {
         clientEventEmitter?.onPlaybackFailed(errorMessage)
         closePlayback()
@@ -400,12 +405,16 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
       val libraryItemId = playbackSession.libraryItemId ?: "" // Must be true since direct play
       val episodeId = playbackSession.episodeId
       apiHandler.playLibraryItem(libraryItemId, episodeId, playItemRequestPayload) {
+        if (it == null) {
+          Log.e(tag, "Failed to start new playback session")
+        } else {
           Handler(Looper.getMainLooper()).post {
             preparePlayer(it, true, null)
           }
         }
       }
     }
+  }
 
   fun switchToPlayer(useCastPlayer: Boolean) {
     val wasPlaying = currentPlayer.isPlaying

android/app/src/main/java/com/audiobookshelf/app/plugins/AbsAudioPlayer.kt

@@ -165,7 +165,7 @@ class AbsAudioPlayer : Plugin() {
 
     if (libraryItemId.isEmpty()) {
       Log.e(tag, "Invalid call to play library item no library item id")
-      return call.resolve()
+      return call.resolve(JSObject("{\"error\":\"Invalid request\"}"))
     }
 
     if (libraryItemId.startsWith("local")) { // Play local media item
@@ -176,7 +176,7 @@ class AbsAudioPlayer : Plugin() {
           episode = podcastMedia.episodes?.find { ep -> ep.id == episodeId }
           if (episode == null) {
             Log.e(tag, "prepareLibraryItem: Podcast episode not found $episodeId")
-            return call.resolve(JSObject())
+            return call.resolve(JSObject("{\"error\":\"Podcast episode not found\"}"))
           }
         }
 
@@ -191,7 +191,9 @@ class AbsAudioPlayer : Plugin() {
       val playItemRequestPayload = playerNotificationService.getPlayItemRequestPayload(false)
 
       apiHandler.playLibraryItem(libraryItemId, episodeId, playItemRequestPayload) {
-
+        if (it == null) {
+          call.resolve(JSObject("{\"error\":\"Server play request failed\"}"))
+        } else {
           Handler(Looper.getMainLooper()).post {
             Log.d(tag, "Preparing Player TEST ${jacksonMapper.writeValueAsString(it)}")
             playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
@@ -201,6 +203,7 @@ class AbsAudioPlayer : Plugin() {
         }
       }
     }
+  }
 
   @PluginMethod
   fun getCurrentTime(call: PluginCall) {

android/app/src/main/java/com/audiobookshelf/app/plugins/AbsDownloader.kt

@@ -143,6 +143,9 @@ class AbsDownloader : Plugin() {
     }
 
     apiHandler.getLibraryItemWithProgress(libraryItemId, episodeId) { libraryItem ->
+      if (libraryItem == null) {
+        call.resolve(JSObject("{\"error\":\"Server request failed\"}"))
+      } else {
         Log.d(tag, "Got library item from server ${libraryItem.id}")
 
         val localFolder = DeviceManager.dbManager.getLocalFolder(localFolderId)
@@ -171,6 +174,7 @@ class AbsDownloader : Plugin() {
         }
       }
     }
+  }
 
   // Clean folder path so it can be used in URL
   private fun cleanRelPath(relPath: String): String {

android/app/src/main/java/com/audiobookshelf/app/server/ApiHandler.kt

@@ -135,21 +135,31 @@ class ApiHandler(var ctx:Context) {
     }
   }
 
-  fun getLibraryItem(libraryItemId:String, cb: (LibraryItem) -> Unit) {
+  fun getLibraryItem(libraryItemId:String, cb: (LibraryItem?) -> Unit) {
     getRequest("/api/items/$libraryItemId?expanded=1", null, null) {
+      if (it.has("error")) {
+        Log.e(tag, it.getString("error") ?: "getLibraryItem Failed")
+        cb(null)
+      } else {
         val libraryItem = jacksonMapper.readValue<LibraryItem>(it.toString())
         cb(libraryItem)
       }
     }
+  }
 
-  fun getLibraryItemWithProgress(libraryItemId:String, episodeId:String?, cb: (LibraryItem) -> Unit) {
+  fun getLibraryItemWithProgress(libraryItemId:String, episodeId:String?, cb: (LibraryItem?) -> Unit) {
     var requestUrl = "/api/items/$libraryItemId?expanded=1&include=progress"
     if (!episodeId.isNullOrEmpty()) requestUrl += "&episode=$episodeId"
     getRequest(requestUrl, null, null) {
+      if (it.has("error")) {
+        Log.e(tag, it.getString("error") ?: "getLibraryItemWithProgress Failed")
+        cb(null)
+      } else {
         val libraryItem = jacksonMapper.readValue<LibraryItem>(it.toString())
         cb(libraryItem)
       }
     }
+  }
 
   fun getLibraryItems(libraryId:String, cb: (List<LibraryItem>) -> Unit) {
     getRequest("/api/libraries/$libraryId/items?limit=100&minified=1", null, null) {
@@ -186,17 +196,22 @@ class ApiHandler(var ctx:Context) {
     }
   }
 
-  fun playLibraryItem(libraryItemId:String, episodeId:String?, playItemRequestPayload:PlayItemRequestPayload, cb: (PlaybackSession) -> Unit) {
+  fun playLibraryItem(libraryItemId:String, episodeId:String?, playItemRequestPayload:PlayItemRequestPayload, cb: (PlaybackSession?) -> Unit) {
     val payload = JSObject(jacksonMapper.writeValueAsString(playItemRequestPayload))
 
     val endpoint = if (episodeId.isNullOrEmpty()) "/api/items/$libraryItemId/play" else "/api/items/$libraryItemId/play/$episodeId"
     postRequest(endpoint, payload) {
+      if (it.has("error")) {
+        Log.e(tag, it.getString("error") ?: "Play Library Item Failed")
+        cb(null)
+      } else {
         it.put("serverConnectionConfigId", DeviceManager.serverConnectionConfig?.id)
         it.put("serverAddress", DeviceManager.serverAddress)
         val playbackSession = jacksonMapper.readValue<PlaybackSession>(it.toString())
         cb(playbackSession)
       }
     }
+  }
 
   fun sendProgressSync(sessionId:String, syncData: MediaProgressSyncData, cb: (Boolean) -> Unit) {
     val payload = JSObject(jacksonMapper.writeValueAsString(syncData))
@@ -236,10 +251,12 @@ class ApiHandler(var ctx:Context) {
       Log.d(tag, "Sending sync local progress request with ${localMediaProgress.size} progress items")
       val payload = JSObject(jacksonMapper.writeValueAsString(LocalMediaProgressSyncPayload(localMediaProgress)))
       postRequest("/api/me/sync-local-progress", payload) {
-        Log.d(tag, "Media Progress Sync payload $payload - response ${it.toString()}")
+        Log.d(tag, "Media Progress Sync payload $payload - response ${it}")
 
         if (it.toString() == "{}") {
           Log.e(tag, "Progress sync received empty object")
+        } else if (it.has("error")) {
+          Log.e(tag, it.getString("error") ?: "Progress sync error")
         } else {
           val progressSyncResponsePayload = jacksonMapper.readValue<MediaProgressSyncResponsePayload>(it.toString())
 

components/app/AudioPlayerContainer.vue

@@ -185,11 +185,17 @@ export default {
       }
       AbsAudioPlayer.prepareLibraryItem({ libraryItemId, episodeId: null, playWhenReady: false, playbackRate })
         .then((data) => {
+          if (data.error) {
+            const errorMsg = data.error || 'Failed to play'
+            this.$toast.error(errorMsg)
+          } else {
             console.log('Library item play response', JSON.stringify(data))
             AbsAudioPlayer.requestSession()
+          }
         })
         .catch((error) => {
           console.error('Failed', error)
+          this.$toast.error('Failed to play')
         })
     },
     async playLibraryItem(payload) {
@@ -220,15 +226,21 @@ export default {
       console.log('Called playLibraryItem', libraryItemId)
       AbsAudioPlayer.prepareLibraryItem({ libraryItemId, episodeId, playWhenReady: true, playbackRate })
         .then((data) => {
+          if (data.error) {
+            const errorMsg = data.error || 'Failed to play'
+            this.$toast.error(errorMsg)
+          } else {
             console.log('Library item play response', JSON.stringify(data))
             if (!libraryItemId.startsWith('local')) {
               this.serverLibraryItemId = libraryItemId
             } else {
               this.serverLibraryItemId = serverLibraryItemId
             }
+          }
         })
         .catch((error) => {
           console.error('Failed', error)
+          this.$toast.error('Failed to play')
         })
     },
     pauseItem() {