Update:Metered network connections to send progress syncs every 60s instead of every 5s and show metered/unmetered in connection status icon #238

android/app/build.gradle

@@ -29,8 +29,8 @@ android {
         applicationId "com.audiobookshelf.app"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 83
-        versionName "0.9.52-beta"
+        versionCode 84
+        versionName "0.9.53-beta"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
@@ -111,7 +111,7 @@ dependencies {
   implementation 'io.github.pilgr:paperdb:2.7.2'
 
   // Simple Storage
-  implementation "com.anggrayudi:storage:1.3.0"
+  implementation "com.anggrayudi:storage:0.14.0"
 
   // OK HTTP
   implementation 'com.squareup.okhttp3:okhttp:4.9.2'

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

@@ -236,32 +236,37 @@ class MediaManager(var apiHandler: ApiHandler, var ctx: Context) {
         serverConfigIdUsed = DeviceManager.serverConnectionConfigId
 
         loadLibraries { libraries ->
-          val library = libraries[0]
-          Log.d(tag, "Loading categories for library ${library.name} - ${library.id} - ${library.mediaType}")
+          if (libraries.isEmpty()) {
+            Log.w(tag, "No libraries returned from server request")
+            cb(cats) // Return download category only
+          } else {
+            val library = libraries[0]
+            Log.d(tag, "Loading categories for library ${library.name} - ${library.id} - ${library.mediaType}")
 
-          loadLibraryCategories(library.id) { libraryCategories ->
+            loadLibraryCategories(library.id) { libraryCategories ->
 
-            // Only using book or podcast library categories for now
-            libraryCategories.forEach {
+              // Only using book or podcast library categories for now
+              libraryCategories.forEach {
 
-              // Add items in continue listening to serverLibraryItems
-              if (it.id == "continue-listening") {
-                it.entities.forEach { libraryItemWrapper ->
-                  val libraryItem = libraryItemWrapper as LibraryItem
-                  if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
-                    serverLibraryItems.add(libraryItem)
+                // Add items in continue listening to serverLibraryItems
+                if (it.id == "continue-listening") {
+                  it.entities.forEach { libraryItemWrapper ->
+                    val libraryItem = libraryItemWrapper as LibraryItem
+                    if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+                      serverLibraryItems.add(libraryItem)
+                    }
                   }
                 }
+
+                // Log.d(tag, "Found library category ${it.label} with type ${it.type}")
+                if (it.type == library.mediaType) {
+                  // Log.d(tag, "Using library category ${it.id}")
+                  cats.add(it)
+                }
               }
 
-              // Log.d(tag, "Found library category ${it.label} with type ${it.type}")
-              if (it.type == library.mediaType) {
-                // Log.d(tag, "Using library category ${it.id}")
-                cats.add(it)
-              }
+              cb(cats)
             }
-
-            cb(cats)
           }
         }
       } else { // Not connected/no internet sent downloaded cats only

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

@@ -19,6 +19,7 @@ data class MediaProgressSyncData(
 
 class MediaProgressSyncer(val playerNotificationService:PlayerNotificationService, private val apiHandler: ApiHandler) {
   private val tag = "MediaProgressSync"
+  private val METERED_CONNECTION_SYNC_INTERVAL = 60000
 
   private var listeningTimerTask: TimerTask? = null
   var listeningTimerRunning:Boolean = false
@@ -46,7 +47,10 @@ class MediaProgressSyncer(val playerNotificationService:PlayerNotificationServic
       } else {
         return
       }
+    } else if (playerNotificationService.getCurrentPlaybackSessionId() != currentSessionId) {
+      currentLocalMediaProgress = null
     }
+
     listeningTimerRunning = true
     lastSyncTime = System.currentTimeMillis()
     currentPlaybackSession = playerNotificationService.getCurrentPlaybackSessionCopy()
@@ -54,8 +58,11 @@ class MediaProgressSyncer(val playerNotificationService:PlayerNotificationServic
     listeningTimerTask = Timer("ListeningTimer", false).schedule(0L, 5000L) {
       Handler(Looper.getMainLooper()).post() {
         if (playerNotificationService.currentPlayer.isPlaying) {
+          // Only sync with server on unmetered connection every 5s OR sync with server if last sync time is >= 60s
+          val shouldSyncServer = PlayerNotificationService.isUnmeteredNetwork || System.currentTimeMillis() - lastSyncTime >= METERED_CONNECTION_SYNC_INTERVAL
+
           val currentTime = playerNotificationService.getCurrentTimeSeconds()
-          sync(currentTime) {
+          sync(shouldSyncServer, currentTime) {
             Log.d(tag, "Sync complete")
           }
         }
@@ -63,13 +70,30 @@ class MediaProgressSyncer(val playerNotificationService:PlayerNotificationServic
     }
   }
 
-  fun stop() {
+  fun stop(cb: () -> Unit) {
     if (!listeningTimerRunning) return
     Log.d(tag, "stop: Stopping listening for $currentDisplayTitle")
 
     val currentTime = playerNotificationService.getCurrentTimeSeconds()
-    sync(currentTime) {
+    sync(true, currentTime) {
       reset()
+      cb()
+    }
+  }
+
+  fun pause(cb: () -> Unit) {
+    if (!listeningTimerRunning) return
+    Log.d(tag, "pause: Pausing progress syncer for $currentDisplayTitle")
+
+    val currentTime = playerNotificationService.getCurrentTimeSeconds()
+    sync(true, currentTime) {
+      listeningTimerTask?.cancel()
+      listeningTimerTask = null
+      listeningTimerRunning = false
+      lastSyncTime = 0L
+      failedSyncs = 0
+
+      cb()
     }
   }
 
@@ -77,19 +101,17 @@ class MediaProgressSyncer(val playerNotificationService:PlayerNotificationServic
     currentPlaybackSession?.let {
       it.updatedAt = mediaProgress.lastUpdate
       it.currentTime = mediaProgress.currentTime
-
       DeviceManager.dbManager.saveLocalPlaybackSession(it)
       saveLocalProgress(it)
     }
   }
 
-  fun sync(currentTime:Double, cb: () -> Unit) {
+  fun sync(shouldSyncServer:Boolean, currentTime:Double, cb: () -> Unit) {
     val diffSinceLastSync = System.currentTimeMillis() - lastSyncTime
     if (diffSinceLastSync < 1000L) {
       return cb()
     }
     val listeningTimeToAdd = diffSinceLastSync / 1000L
-    lastSyncTime = System.currentTimeMillis()
 
     val syncData = MediaProgressSyncData(listeningTimeToAdd,currentPlaybackDuration,currentTime)
 
@@ -105,36 +127,53 @@ class MediaProgressSyncer(val playerNotificationService:PlayerNotificationServic
       currentPlaybackSession?.let {
         DeviceManager.dbManager.saveLocalPlaybackSession(it)
         saveLocalProgress(it)
+        lastSyncTime = System.currentTimeMillis()
 
         // Local library item is linked to a server library item
         // Send sync to server also if connected to this server and local item belongs to this server
-        if (!it.libraryItemId.isNullOrEmpty() && it.serverConnectionConfigId != null && DeviceManager.serverConnectionConfig?.id == it.serverConnectionConfigId) {
-          apiHandler.sendLocalProgressSync(it) {
+        if (shouldSyncServer && !it.libraryItemId.isNullOrEmpty() && it.serverConnectionConfigId != null && DeviceManager.serverConnectionConfig?.id == it.serverConnectionConfigId) {
+          apiHandler.sendLocalProgressSync(it) { syncSuccess ->
             Log.d(
               tag,
               "Local progress sync data sent to server $currentDisplayTitle for time $currentTime"
             )
+            if (syncSuccess) {
+              failedSyncs = 0
+              playerNotificationService.alertSyncSuccess()
+            } else {
+              failedSyncs++
+              if (failedSyncs == 2) {
+                playerNotificationService.alertSyncFailing() // Show alert in client
+                failedSyncs = 0
+              }
+              Log.e(tag, "Local Progress sync failed ($failedSyncs) to send to server $currentDisplayTitle for time $currentTime")
+            }
+
             cb()
           }
         } else {
           cb()
         }
       }
-    } else {
+    } else if (shouldSyncServer) {
       apiHandler.sendProgressSync(currentSessionId, syncData) {
         if (it) {
           Log.d(tag, "Progress sync data sent to server $currentDisplayTitle for time $currentTime")
           failedSyncs = 0
+          playerNotificationService.alertSyncSuccess()
+          lastSyncTime = System.currentTimeMillis()
         } else {
           failedSyncs++
           if (failedSyncs == 2) {
             playerNotificationService.alertSyncFailing() // Show alert in client
             failedSyncs = 0
           }
-          Log.d(tag, "Progress sync failed ($failedSyncs) to send to server $currentDisplayTitle for time $currentTime")
+          Log.e(tag, "Progress sync failed ($failedSyncs) to send to server $currentDisplayTitle for time $currentTime")
         }
         cb()
       }
+    } else {
+      cb()
     }
   }
 

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

@@ -71,32 +71,36 @@ class PlayerListener(var playerNotificationService:PlayerNotificationService) :
       if (player.isPlaying) {
         Log.d(tag, "SeekBackTime: Player is playing")
         if (lastPauseTime > 0 && DeviceManager.deviceData.deviceSettings?.disableAutoRewind != true) {
+          var seekBackTime = 0L
           if (onSeekBack) onSeekBack = false
           else {
             Log.d(tag, "SeekBackTime: playing started now set seek back time $lastPauseTime")
-            var backTime = calcPauseSeekBackTime()
-            if (backTime > 0) {
+            seekBackTime = calcPauseSeekBackTime()
+            if (seekBackTime > 0) {
               // Current chapter is used so that seek back does not go back to the previous chapter
               val currentChapter = playerNotificationService.getCurrentBookChapter()
               val minSeekBackTime = currentChapter?.startMs ?: 0
 
               val currentTime = playerNotificationService.getCurrentTime()
-              val newTime = currentTime - backTime
+              val newTime = currentTime - seekBackTime
               if (newTime < minSeekBackTime) {
-                backTime = currentTime - minSeekBackTime
+                seekBackTime = currentTime - minSeekBackTime
               }
-              Log.d(tag, "SeekBackTime $backTime")
+              Log.d(tag, "SeekBackTime $seekBackTime")
               onSeekBack = true
-              playerNotificationService.seekBackward(backTime)
             }
           }
 
           // Check if playback session still exists or sync media progress if updated
           val pauseLength: Long = System.currentTimeMillis() - lastPauseTime
           if (pauseLength > PAUSE_LEN_BEFORE_RECHECK) {
-            val shouldCarryOn = playerNotificationService.checkCurrentSessionProgress()
+            val shouldCarryOn = playerNotificationService.checkCurrentSessionProgress(seekBackTime)
             if (!shouldCarryOn) return
           }
+
+          if (seekBackTime > 0L) {
+            playerNotificationService.seekBackward(seekBackTime)
+          }
         }
       } else {
         Log.d(tag, "SeekBackTime: Player not playing set last pause time")
@@ -104,12 +108,13 @@ class PlayerListener(var playerNotificationService:PlayerNotificationService) :
       }
 
       // Start/stop progress sync interval
-      Log.d(tag, "Playing ${playerNotificationService.getCurrentBookTitle()}")
       if (player.isPlaying) {
         player.volume = 1F // Volume on sleep timer might have decreased this
         playerNotificationService.mediaProgressSyncer.start()
       } else {
-        playerNotificationService.mediaProgressSyncer.stop()
+        playerNotificationService.mediaProgressSyncer.pause {
+          Log.d(tag, "Media Progress Syncer paused and synced")
+        }
       }
 
       playerNotificationService.clientEventEmitter?.onPlayingUpdate(player.isPlaying)

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

@@ -6,6 +6,10 @@ import android.content.Intent
 import android.graphics.Color
 import android.hardware.Sensor
 import android.hardware.SensorManager
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
 import android.os.*
 import android.support.v4.media.MediaBrowserCompat
 import android.support.v4.media.MediaDescriptionCompat
@@ -45,6 +49,7 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
   companion object {
     var isStarted = false
     var isClosed = false
+    var isUnmeteredNetwork = false
   }
 
   interface ClientEventEmitter {
@@ -58,6 +63,8 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
     fun onPlaybackFailed(errorMessage:String)
     fun onMediaPlayerChanged(mediaPlayer:String)
     fun onProgressSyncFailing()
+    fun onProgressSyncSuccess()
+    fun onNetworkMeteredChanged(isUnmetered:Boolean)
   }
 
   private val tag = "PlayerService"
@@ -163,6 +170,15 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
     super.onCreate()
     ctx = this
 
+    // To listen for network change from metered to unmetered
+    val networkRequest = NetworkRequest.Builder()
+      .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+      .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+      .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
+      .build()
+    val connectivityManager = getSystemService(ConnectivityManager::class.java) as ConnectivityManager
+    connectivityManager.registerNetworkCallback(networkRequest, networkCallback)
+
     DbManager.initialize(ctx)
 
     // Initialize API
@@ -549,10 +565,10 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
 
   // Called from PlayerListener play event
   // check with server if progress has updated since last play and sync progress update
-  fun checkCurrentSessionProgress():Boolean {
+  fun checkCurrentSessionProgress(seekBackTime:Long):Boolean {
     if (currentPlaybackSession == null) return true
 
-    currentPlaybackSession?.let { playbackSession ->
+    mediaProgressSyncer.currentPlaybackSession?.let { playbackSession ->
       if (!apiHandler.isOnline() || playbackSession.isLocalLibraryItemOnly) {
         return true // carry on
       }
@@ -574,16 +590,28 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
             Log.d(tag, "checkCurrentSessionProgress: Media progress was updated since last play time updating from ${playbackSession.currentTime} to ${mediaProgress.currentTime}")
             mediaProgressSyncer.syncFromServerProgress(mediaProgress)
 
+            // Update current playback session stored in PNS since MediaProgressSyncer version is a copy
+            mediaProgressSyncer.currentPlaybackSession?.let { updatedPlaybackSession ->
+              currentPlaybackSession = updatedPlaybackSession
+            }
+
             Handler(Looper.getMainLooper()).post {
               seekPlayer(playbackSession.currentTimeMs)
+              // Should already be playing
+              currentPlayer.volume = 1F // Volume on sleep timer might have decreased this
+              mediaProgressSyncer.start()
+              clientEventEmitter?.onPlayingUpdate(true)
+            }
+          } else {
+            Handler(Looper.getMainLooper()).post {
+              if (seekBackTime > 0L) {
+                seekBackward(seekBackTime)
+              }
+              // Should already be playing
+              currentPlayer.volume = 1F // Volume on sleep timer might have decreased this
+              mediaProgressSyncer.start()
+              clientEventEmitter?.onPlayingUpdate(true)
             }
-          }
-
-          Handler(Looper.getMainLooper()).post {
-            // Should already be playing
-            currentPlayer.volume = 1F // Volume on sleep timer might have decreased this
-            mediaProgressSyncer.start()
-            clientEventEmitter?.onPlayingUpdate(true)
           }
         }
       } else {
@@ -606,6 +634,10 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
           } else {
               Log.d(tag, "checkCurrentSessionProgress: Playback session still available on server")
               Handler(Looper.getMainLooper()).post {
+                if (seekBackTime > 0L) {
+                  seekBackward(seekBackTime)
+                }
+
                 currentPlayer.volume = 1F // Volume on sleep timer might have decreased this
                 mediaProgressSyncer.start()
                 clientEventEmitter?.onPlayingUpdate(true)
@@ -670,6 +702,13 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
 
   fun closePlayback() {
     Log.d(tag, "closePlayback")
+    if (mediaProgressSyncer.listeningTimerRunning) {
+      Log.i(tag, "About to close playback so stopping media progress syncer first")
+      mediaProgressSyncer.stop {
+        Log.d(tag, "Media Progress syncer stopped and synced")
+      }
+    }
+
     try {
       currentPlayer.stop()
       currentPlayer.clearMediaItems()
@@ -717,6 +756,10 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
     clientEventEmitter?.onProgressSyncFailing()
   }
 
+  fun alertSyncSuccess() {
+    clientEventEmitter?.onProgressSyncSuccess()
+  }
+
   //
   // MEDIA BROWSER STUFF (ANDROID AUTO)
   //
@@ -886,5 +929,19 @@ class PlayerNotificationService : MediaBrowserServiceCompat()  {
       }
     }
   }
+
+  private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+    // Network capabilities have changed for the network
+    override fun onCapabilitiesChanged(
+      network: Network,
+      networkCapabilities: NetworkCapabilities
+    ) {
+      super.onCapabilitiesChanged(network, networkCapabilities)
+      val unmetered = networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
+      Log.i(tag, "Network capabilities changed is unmetered = $unmetered")
+      isUnmeteredNetwork = unmetered
+      clientEventEmitter?.onNetworkMeteredChanged(unmetered)
+    }
+  }
 }
 

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

@@ -80,6 +80,14 @@ class AbsAudioPlayer : Plugin() {
         override fun onProgressSyncFailing() {
           emit("onProgressSyncFailing", "")
         }
+
+        override fun onProgressSyncSuccess() {
+          emit("onProgressSyncSuccess", "")
+        }
+
+        override fun onNetworkMeteredChanged(isUnmetered:Boolean) {
+          emit("onNetworkMeteredChanged", isUnmetered)
+        }
       })
     }
     mainActivity.pluginCallback = foregroundServiceReady
@@ -173,7 +181,21 @@ class AbsAudioPlayer : Plugin() {
         Handler(Looper.getMainLooper()).post {
           Log.d(tag, "prepareLibraryItem: Preparing Local Media item ${jacksonMapper.writeValueAsString(it)}")
           val playbackSession = it.getPlaybackSession(episode)
-          playerNotificationService.preparePlayer(playbackSession, playWhenReady, playbackRate)
+
+          if (playerNotificationService.mediaProgressSyncer.listeningTimerRunning) { // If progress syncing then first stop before preparing next
+            playerNotificationService.mediaProgressSyncer.stop {
+              Log.d(tag, "Media progress syncer was already syncing - stopped")
+              Handler(Looper.getMainLooper()).post { // TODO: This was needed again which is probably a design a flaw
+                playerNotificationService.preparePlayer(
+                  playbackSession,
+                  playWhenReady,
+                  playbackRate
+                )
+              }
+            }
+          } else {
+            playerNotificationService.preparePlayer(playbackSession, playWhenReady, playbackRate)
+          }
         }
         return call.resolve(JSObject())
       }
@@ -184,9 +206,20 @@ class AbsAudioPlayer : Plugin() {
         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)
+            Log.d(tag, "Preparing Player playback session ${jacksonMapper.writeValueAsString(it)}")
+
+            if (playerNotificationService.mediaProgressSyncer.listeningTimerRunning) { // If progress syncing then first stop before preparing next
+              playerNotificationService.mediaProgressSyncer.stop {
+                Log.d(tag, "Media progress syncer was already syncing - stopped")
+                Handler(Looper.getMainLooper()).post { // TODO: This was needed again which is probably a design a flaw
+                  playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+                }
+              }
+            } else {
+              playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+            }
           }
 
           call.resolve(JSObject(jacksonMapper.writeValueAsString(it)))

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

@@ -79,6 +79,12 @@ class ApiHandler(var ctx:Context) {
     return false
   }
 
+  fun isUsingCellularData(): Boolean {
+    val connectivityManager = ctx.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
+    return capabilities?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true
+  }
+
   fun makeRequest(request:Request, httpClient:OkHttpClient?, cb: (JSObject) -> Unit) {
     val client = httpClient ?: defaultClient
     client.newCall(request).enqueue(object : Callback {
@@ -230,11 +236,15 @@ class ApiHandler(var ctx:Context) {
     }
   }
 
-  fun sendLocalProgressSync(playbackSession:PlaybackSession, cb: () -> Unit) {
+  fun sendLocalProgressSync(playbackSession:PlaybackSession, cb: (Boolean) -> Unit) {
     val payload = JSObject(jacksonMapper.writeValueAsString(playbackSession))
 
     postRequest("/api/session/local", payload) {
-      cb()
+      if (!it.getString("error").isNullOrEmpty()) {
+        cb(false)
+      } else {
+        cb(true)
+      }
     }
   }
 

components/app/AudioPlayer.vue

@@ -34,6 +34,10 @@
       <div class="cover-container bookCoverWrapper bg-black bg-opacity-75 w-full h-full">
         <covers-book-cover v-if="libraryItem || localLibraryItemCoverSrc" :library-item="libraryItem" :download-cover="localLibraryItemCoverSrc" :width="bookCoverWidth" :book-cover-aspect-ratio="bookCoverAspectRatio" />
       </div>
+
+      <div v-if="syncStatus === $constants.SyncStatus.FAILED" class="absolute top-0 left-0 w-full h-full flex items-center justify-center z-30">
+        <span class="material-icons text-error text-3xl">error</span>
+      </div>
     </div>
 
     <div class="title-author-texts absolute z-30 left-0 right-0 overflow-hidden" @click="clickTitleAndAuthor">
@@ -129,13 +133,16 @@ export default {
       onPlaybackClosedListener: null,
       onPlayingUpdateListener: null,
       onMetadataListener: null,
+      onProgressSyncFailing: null,
+      onProgressSyncSuccess: null,
       touchStartY: 0,
       touchStartTime: 0,
       touchEndY: 0,
       useChapterTrack: false,
       isLoading: false,
       touchTrackStart: false,
-      dragPercent: 0
+      dragPercent: 0,
+      syncStatus: 0
     }
   },
   watch: {
@@ -675,6 +682,7 @@ export default {
 
       this.isEnded = false
       this.isLoading = true
+      this.syncStatus = 0
       this.$store.commit('setPlayerItem', this.playbackSession)
 
       // Set track width
@@ -703,6 +711,8 @@ export default {
       this.onPlaybackFailedListener = AbsAudioPlayer.addListener('onPlaybackFailed', this.onPlaybackFailed)
       this.onPlayingUpdateListener = AbsAudioPlayer.addListener('onPlayingUpdate', this.onPlayingUpdate)
       this.onMetadataListener = AbsAudioPlayer.addListener('onMetadata', this.onMetadata)
+      this.onProgressSyncFailing = AbsAudioPlayer.addListener('onProgressSyncFailing', this.showProgressSyncIsFailing)
+      this.onProgressSyncSuccess = AbsAudioPlayer.addListener('onProgressSyncSuccess', this.showProgressSyncSuccess)
     },
     screenOrientationChange() {
       setTimeout(this.updateScreenSize, 50)
@@ -716,6 +726,12 @@ export default {
     minimizePlayerEvt() {
       console.log('Minimize Player Evt')
       this.showFullscreen = false
+    },
+    showProgressSyncIsFailing() {
+      this.syncStatus = this.$constants.SyncStatus.FAILED
+    },
+    showProgressSyncSuccess() {
+      this.syncStatus = this.$constants.SyncStatus.SUCCESS
     }
   },
   mounted() {
@@ -751,6 +767,8 @@ export default {
     if (this.onPlaybackSessionListener) this.onPlaybackSessionListener.remove()
     if (this.onPlaybackClosedListener) this.onPlaybackClosedListener.remove()
     if (this.onPlaybackFailedListener) this.onPlaybackFailedListener.remove()
+    if (this.onProgressSyncFailing) this.onProgressSyncFailing.remove()
+    if (this.onProgressSyncSuccess) this.onProgressSyncSuccess.remove()
     clearInterval(this.playInterval)
   }
 }

components/app/AudioPlayerContainer.vue

@@ -30,11 +30,9 @@ export default {
       onSleepTimerEndedListener: null,
       onSleepTimerSetListener: null,
       onMediaPlayerChangedListener: null,
-      onProgressSyncFailing: null,
       sleepInterval: null,
       currentEndOfChapterTime: 0,
-      serverLibraryItemId: null,
-      syncFailedToast: null
+      serverLibraryItemId: null
     }
   },
   watch: {
@@ -255,10 +253,6 @@ export default {
     onMediaPlayerChanged(data) {
       var mediaPlayer = data.value
       this.$store.commit('setMediaPlayer', mediaPlayer)
-    },
-    showProgressSyncIsFailing() {
-      if (!isNaN(this.syncFailedToast)) this.$toast.dismiss(this.syncFailedToast)
-      this.syncFailedToast = this.$toast('Progress is not being synced', { timeout: false, type: 'error' })
     }
   },
   mounted() {
@@ -266,7 +260,6 @@ export default {
     this.onSleepTimerEndedListener = AbsAudioPlayer.addListener('onSleepTimerEnded', this.onSleepTimerEnded)
     this.onSleepTimerSetListener = AbsAudioPlayer.addListener('onSleepTimerSet', this.onSleepTimerSet)
     this.onMediaPlayerChangedListener = AbsAudioPlayer.addListener('onMediaPlayerChanged', this.onMediaPlayerChanged)
-    this.onProgressSyncFailing = AbsAudioPlayer.addListener('onProgressSyncFailing', this.showProgressSyncIsFailing)
 
     this.playbackSpeed = this.$store.getters['user/getUserSetting']('playbackRate')
     console.log(`[AudioPlayerContainer] Init Playback Speed: ${this.playbackSpeed}`)
@@ -283,7 +276,6 @@ export default {
     if (this.onSleepTimerEndedListener) this.onSleepTimerEndedListener.remove()
     if (this.onSleepTimerSetListener) this.onSleepTimerSetListener.remove()
     if (this.onMediaPlayerChangedListener) this.onMediaPlayerChangedListener.remove()
-    if (this.onProgressSyncFailing) this.onProgressSyncFailing.remove()
 
     // if (this.$server.socket) {
     //   this.$server.socket.off('stream_open', this.streamOpen)

components/connection/ServerConnectForm.vue

@@ -16,6 +16,9 @@
       </template>
       <div v-else class="w-full">
         <form v-show="!showAuth" @submit.prevent="submit" novalidate class="w-full">
+          <div v-if="serverConnectionConfigs.length" class="flex items-center mb-4" @click="showServerList">
+            <span class="material-icons text-gray-300">arrow_back</span>
+          </div>
           <h2 class="text-lg leading-7 mb-2">Server address</h2>
           <ui-text-input v-model="serverConfig.address" :disabled="processing || !networkConnected || !!serverConfig.id" placeholder="http://55.55.55.55:13378" type="url" class="w-full h-10" />
           <div class="flex justify-end items-center mt-6">
@@ -149,7 +152,7 @@ export default {
       var payload = await this.authenticateToken()
 
       if (payload) {
-        this.setUserAndConnection(payload.user, payload.userDefaultLibraryId)
+        this.setUserAndConnection(payload)
       } else {
         this.showAuth = true
       }
@@ -273,7 +276,8 @@ export default {
         this.error = 'Invalid username'
         return
       }
-      const duplicateConfig = this.serverConnectionConfigs.find((scc) => scc.address === this.serverConfig.address && scc.username === this.serverConfig.username)
+
+      const duplicateConfig = this.serverConnectionConfigs.find((scc) => scc.address === this.serverConfig.address && scc.username === this.serverConfig.username && this.serverConfig.id !== scc.id)
       if (duplicateConfig) {
         this.error = 'Config already exists for this address and username'
         return
@@ -285,14 +289,16 @@ export default {
       var payload = await this.requestServerLogin()
       this.processing = false
       if (payload) {
-        this.setUserAndConnection(payload.user, payload.userDefaultLibraryId)
+        this.setUserAndConnection(payload)
       }
     },
-    async setUserAndConnection(user, userDefaultLibraryId) {
+    async setUserAndConnection({ user, userDefaultLibraryId, serverSettings }) {
       if (!user) return
 
       console.log('Successfully logged in', JSON.stringify(user))
 
+      this.$store.commit('setServerSettings', serverSettings)
+
       // Set library - Use last library if set and available fallback to default user library
       var lastLibraryId = await this.$localStore.getLastLibraryId()
       if (lastLibraryId && (!user.librariesAccessible.length || user.librariesAccessible.includes(lastLibraryId))) {

components/widgets/ConnectionIndicator.vue

@@ -24,6 +24,9 @@ export default {
     networkConnectionType() {
       return this.$store.state.networkConnectionType
     },
+    isNetworkUnmetered() {
+      return this.$store.state.isNetworkUnmetered
+    },
     isCellular() {
       return this.networkConnectionType === 'cellular'
     },
@@ -43,6 +46,7 @@ export default {
     iconClass() {
       if (!this.networkConnected) return 'text-error'
       else if (!this.socketConnected) return 'text-warning'
+      else if (!this.isNetworkUnmetered) return 'text-yellow-400'
       else if (this.isCellular) return 'text-gray-200'
       else return 'text-success'
     }
@@ -50,14 +54,15 @@ export default {
   methods: {
     showAlertDialog() {
       var msg = ''
+      var meteredString = this.isNetworkUnmetered ? 'unmetered' : 'metered'
       if (!this.networkConnected) {
         msg = 'No internet'
       } else if (!this.socketConnected) {
         msg = 'Socket not connected'
       } else if (this.isCellular) {
-        msg = 'Socket connected over cellular'
+        msg = `Socket connected over ${meteredString} cellular`
       } else {
-        msg = 'Socket connected over wifi'
+        msg = `Socket connected over ${meteredString} wifi`
       }
       Dialog.alert({
         title: 'Connection Status',

layouts/default.vue

@@ -154,9 +154,6 @@ export default {
     socketConnectionFailed(err) {
       this.$toast.error('Socket connection error: ' + err.message)
     },
-    socketInit(data) {
-      console.log('Socket init', data)
-    },
     async initLibraries() {
       if (this.inittingLibraries) {
         return
@@ -255,7 +252,6 @@ export default {
     }
   },
   async mounted() {
-    this.$socket.on('initialized', this.socketInit)
     this.$socket.on('user_updated', this.userUpdated)
     this.$socket.on('user_media_progress_updated', this.userMediaProgressUpdated)
 
@@ -283,7 +279,6 @@ export default {
     }
   },
   beforeDestroy() {
-    this.$socket.off('initialized', this.socketInit)
     this.$socket.off('user_updated', this.userUpdated)
     this.$socket.off('user_media_progress_updated', this.userMediaProgressUpdated)
   }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "audiobookshelf-app",
-  "version": "0.9.52-beta",
+  "version": "0.9.53-beta",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "audiobookshelf-app",
-  "version": "0.9.52-beta",
+  "version": "0.9.53-beta",
   "author": "advplyr",
   "scripts": {
     "dev": "nuxt --hostname 0.0.0.0 --port 1337",

pages/bookshelf/index.vue

@@ -183,12 +183,10 @@ export default {
       })
     },
     initListeners() {
-      // this.$server.on('initialized', this.socketInit)
       this.$eventBus.$on('library-changed', this.libraryChanged)
       // this.$eventBus.$on('downloads-loaded', this.downloadsLoaded)
     },
     removeListeners() {
-      // this.$server.off('initialized', this.socketInit)
       this.$eventBus.$off('library-changed', this.libraryChanged)
       // this.$eventBus.$off('downloads-loaded', this.downloadsLoaded)
     }

pages/localMedia/folders/_id.vue

@@ -17,7 +17,7 @@
     <div v-else class="w-full media-item-container overflow-y-auto">
       <template v-for="mediaItem in localLibraryItems">
         <nuxt-link :to="`/localMedia/item/${mediaItem.id}`" :key="mediaItem.id" class="flex my-1">
-          <div class="w-12 h-12 bg-primary">
+          <div class="w-12 h-12 min-w-12 min-h-12 bg-primary">
             <img v-if="mediaItem.coverPathSrc" :src="mediaItem.coverPathSrc" class="w-full h-full object-contain" />
           </div>
           <div class="flex-grow px-2">

plugins/constants.js

@@ -5,6 +5,12 @@ const DownloadStatus = {
   FAILED: 3
 }
 
+const SyncStatus = {
+  UNSET: 0,
+  SUCCESS: 1,
+  FAILED: 2
+}
+
 const CoverDestination = {
   METADATA: 0,
   AUDIOBOOK: 1
@@ -31,6 +37,7 @@ const PlayerState = {
 
 const Constants = {
   DownloadStatus,
+  SyncStatus,
   CoverDestination,
   BookCoverAspectRatio,
   PlayMethod,

plugins/server.js

@@ -80,9 +80,6 @@ class ServerSocket extends EventEmitter {
 
   onInit(data) {
     console.log('[SOCKET] Initial socket data received', data)
-    if (data.serverSettings) {
-      this.$store.commit('setServerSettings', data.serverSettings)
-    }
     this.emit('initialized', true)
   }
 

store/index.js

@@ -1,4 +1,5 @@
 import { Network } from '@capacitor/network'
+import { AbsAudioPlayer } from '@/plugins/capacitor'
 
 export const state = () => ({
   deviceData: null,
@@ -12,6 +13,7 @@ export const state = () => ({
   socketConnected: false,
   networkConnected: false,
   networkConnectionType: null,
+  isNetworkUnmetered: true,
   isFirstLoad: true,
   hasStoragePermission: false,
   selectedLibraryItem: null,
@@ -62,6 +64,12 @@ export const actions = {
       console.log('Network status changed', status.connected, status.connectionType)
       commit('setNetworkStatus', status)
     })
+
+    AbsAudioPlayer.addListener('onNetworkMeteredChanged', (payload) => {
+      const isUnmetered = payload.value
+      console.log('On network metered changed', isUnmetered)
+      commit('setIsNetworkUnmetered', isUnmetered)
+    })
   }
 }
 
@@ -114,6 +122,9 @@ export const mutations = {
     state.networkConnected = val.connected
     state.networkConnectionType = val.connectionType
   },
+  setIsNetworkUnmetered(state, val) {
+    state.isNetworkUnmetered = val
+  },
   openReader(state, libraryItem) {
     state.selectedLibraryItem = libraryItem
     state.showReader = true

tailwind.config.js

@@ -39,6 +39,12 @@ module.exports = {
       },
       maxWidth: {
         '24': '6rem'
+      },
+      minWidth: {
+        '12': '3rem'
+      },
+      minHeight: {
+        '12': '3rem'
       }
     }
   },