Merge remote-tracking branch 'origin/master'

Author: theovilardo

app/src/main/java/com/theveloper/pixelplay/data/navidrome/NavidromeRepository.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.security.crypto.EncryptedSharedPreferences
 import androidx.security.crypto.MasterKey
+import com.theveloper.pixelplay.R
 import com.theveloper.pixelplay.data.database.AlbumEntity
 import com.theveloper.pixelplay.data.database.ArtistEntity
 import com.theveloper.pixelplay.data.database.MusicDao
@@ -25,18 +26,25 @@ import com.theveloper.pixelplay.data.stream.BulkSyncResult
 import com.theveloper.pixelplay.data.stream.CloudMusicUtils
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
 import org.json.JSONObject
 import timber.log.Timber
+import java.util.concurrent.atomic.AtomicInteger
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.math.absoluteValue
+import androidx.core.content.edit
 
 /**
  * Repository for Navidrome/Subsonic music service.
@@ -51,12 +59,14 @@ class NavidromeRepository @Inject constructor(
     private val playlistPreferencesRepository: PlaylistPreferencesRepository,
     @ApplicationContext private val context: Context
 ) {
-    private companion object {
+    companion object {
+        const val SYNC_THRESHOLD_MS = 24 * 60 * 60 * 1000L // 24 hours
         private const val TAG = "NavidromeRepo"
         private const val PREFS_NAME = "navidrome_prefs"
         private const val KEY_SERVER_URL = "server_url"
         private const val KEY_USERNAME = "username"
         private const val KEY_PASSWORD = "password"
+        private const val KEY_LAST_FULL_SYNC = "last_full_sync"
 
         // ID offsets for unified library (following Netease: 3-5, QQ: 6-8)
         // Using negative offsets to prevent collisions with MediaStore IDs
@@ -135,6 +145,10 @@ class NavidromeRepository @Inject constructor(
     val username: String?
         get() = prefs.getString(KEY_USERNAME, null)
 
+    var lastFullSyncTime: Long
+        get() = prefs.getLong(KEY_LAST_FULL_SYNC, 0L)
+        set(value) = prefs.edit { putLong(KEY_LAST_FULL_SYNC, value) }
+
     /**
      * Login to Navidrome server with credentials.
      *
@@ -166,11 +180,11 @@ class NavidromeRepository @Inject constructor(
                 }
 
                 // Save credentials
-                prefs.edit()
-                    .putString(KEY_SERVER_URL, credentials.normalizedServerUrl)
-                    .putString(KEY_USERNAME, username)
-                    .putString(KEY_PASSWORD, password)
-                    .apply()
+                prefs.edit {
+                    putString(KEY_SERVER_URL, credentials.normalizedServerUrl)
+                        .putString(KEY_USERNAME, username)
+                        .putString(KEY_PASSWORD, password)
+                }
 
                 _isLoggedInFlow.value = true
                 Timber.d("$TAG: Login successful for $username@$serverUrl")
@@ -190,7 +204,7 @@ class NavidromeRepository @Inject constructor(
     suspend fun logout() {
         Timber.d("$TAG: Logging out")
         api.clearCredentials()
-        prefs.edit().clear().apply()
+        prefs.edit { clear() }
 
         // Delete all Navidrome playlists from database
         val playlistsToDelete = dao.getAllPlaylistsList()
@@ -363,7 +377,9 @@ class NavidromeRepository @Inject constructor(
     /**
      * Sync all songs from the server library by fetching all albums.
      */
-    suspend fun syncLibrarySongs(): Result<Int> {
+    suspend fun syncLibrarySongs(
+        onProgress: ((Float, String) -> Unit)? = null
+    ): Result<Int> {
         if (!isLoggedIn) {
             return Result.failure(Exception("Not logged in"))
         }
@@ -373,30 +389,59 @@ class NavidromeRepository @Inject constructor(
                 Timber.d("$TAG: Syncing library songs from server")
                 val allSongs = mutableListOf<NavidromeSong>()
                 val pageSize = 500
+                
+                onProgress?.invoke(0.1f, context.getString(R.string.dash_status_fetching_albums))
                 val fetchedAlbums = fetchAllAlbums(pageSize)
 
-                // Fetch songs for each album
-                for (albumJson in fetchedAlbums) {
-                    val albumId = albumJson.optString("id", "")
-                    if (albumId.isBlank()) continue
-
-                    val songsResult = api.getAlbum(albumId)
-                    songsResult.fold(
-                        onSuccess = { songJsons ->
-                            val songs = NavidromeResponseParser.parseSongs(songJsons)
-                            allSongs.addAll(songs)
-                        },
-                        onFailure = {
-                            Timber.w(it, "$TAG: Failed to fetch songs for album $albumId")
+                // Fetch songs for each album in parallel
+                val totalAlbums = fetchedAlbums.size
+                val concurrencyLimit = 5
+                val semaphore = Semaphore(concurrencyLimit)
+                val processedCount = AtomicInteger(0)
+
+                val albumSongLists = coroutineScope {
+                    fetchedAlbums.map { albumJson ->
+                        async {
+                            semaphore.withPermit {
+                                val albumId = albumJson.optString("id", "")
+                                val albumTitle = albumJson.optString("title", "Unknown Album")
+                                if (albumId.isBlank()) return@withPermit emptyList()
+
+                                val songsResult = api.getAlbum(albumId)
+                                val currentProcessed = processedCount.incrementAndGet()
+                                
+                                val progress = 0.1f + (currentProcessed.toFloat() / totalAlbums.coerceAtLeast(1) * 0.8f)
+                                onProgress?.invoke(
+                                    progress, 
+                                    context.getString(R.string.dash_status_fetching_songs_from_format, albumTitle)
+                                )
+
+                                songsResult.fold(
+                                    onSuccess = { songJsons ->
+                                        NavidromeResponseParser.parseSongs(songJsons)
+                                    },
+                                    onFailure = {
+                                        Timber.w(it, "$TAG: Failed to fetch songs for album $albumId")
+                                        emptyList()
+                                    }
+                                )
+                            }
                         }
-                    )
+                    }.awaitAll()
                 }
 
+                allSongs.addAll(albumSongLists.flatten())
+
                 if (allSongs.isEmpty()) {
                     Timber.d("$TAG: No library songs found on server")
+                    onProgress?.invoke(1f, context.getString(R.string.dash_status_no_songs_found))
                     return@withContext Result.success(0)
                 }
 
+                onProgress?.invoke(
+                    0.95f, 
+                    context.getString(R.string.dash_status_saving_songs_format, allSongs.size)
+                )
                 // Deduplicate by song ID
                 val uniqueSongs = allSongs.distinctBy { it.id }
 
@@ -409,6 +454,7 @@ class NavidromeRepository @Inject constructor(
                 dao.insertSongs(entities)
 
                 Timber.d("$TAG: Synced ${entities.size} library songs from ${fetchedAlbums.size} albums")
+                onProgress?.invoke(1f, context.getString(R.string.dash_status_library_sync_complete))
                 Result.success(entities.size)
             } catch (e: Exception) {
                 Timber.e(e, "$TAG: Failed to sync library songs")
@@ -445,18 +491,25 @@ class NavidromeRepository @Inject constructor(
     /**
      * Sync all playlists and their songs, plus library songs.
      */
-    suspend fun syncAllPlaylistsAndSongs(): Result<BulkSyncResult> {
+    suspend fun syncAllPlaylistsAndSongs(
+        onProgress: ((Float, String) -> Unit)? = null
+    ): Result<BulkSyncResult> {
         return withContext(Dispatchers.IO) {
             var syncedSongCount = 0
             var failedPlaylistCount = 0
 
+            onProgress?.invoke(0.05f, context.getString(R.string.dash_status_syncing_library))
             // Sync library songs (all albums)
-            val libResult = syncLibrarySongs()
+            val libResult = syncLibrarySongs { progress, message ->
+                // Map library sync progress (0-1) to 0.05-0.4 range
+                onProgress?.invoke(0.05f + (progress * 0.35f), message)
+            }
             libResult.fold(
                 onSuccess = { count -> syncedSongCount += count },
                 onFailure = { Timber.w(it, "$TAG: Failed syncing library songs") }
             )
 
+            onProgress?.invoke(0.4f, context.getString(R.string.dash_status_fetching_playlists))
             // Sync playlists
             val playlistResult = syncPlaylists().getOrElse {
                 // Playlists failed but library songs may have synced
@@ -474,7 +527,17 @@ class NavidromeRepository @Inject constructor(
                 )
             }
 
-            playlistResult.forEach { playlist ->
+            val totalPlaylists = playlistResult.size
+            playlistResult.forEachIndexed { index, playlist ->
+                val progressBase = 0.4f
+                val progressStep = 0.5f / totalPlaylists.coerceAtLeast(1)
+                val currentProgress = progressBase + (index * progressStep)
+                
+                onProgress?.invoke(
+                    currentProgress, 
+                    context.getString(R.string.dash_status_syncing_playlist_format, playlist.name)
+                )
+                
                 val songSyncResult = syncPlaylistSongs(playlist.id)
                 songSyncResult.fold(
                     onSuccess = { count -> syncedSongCount += count },
@@ -485,13 +548,20 @@ class NavidromeRepository @Inject constructor(
                 )
             }
 
+            onProgress?.invoke(0.95f, context.getString(R.string.dash_status_updating_local))
             // Sync to unified library once after everything is synced
             try {
                 syncUnifiedLibrarySongsFromNavidrome()
             } catch (e: Exception) {
                 Timber.e(e, "$TAG: Failed to sync unified library")
             }
 
+            onProgress?.invoke(1f, context.getString(R.string.dash_status_sync_complete))
+
+            if (failedPlaylistCount == 0) {
+                lastFullSyncTime = System.currentTimeMillis()
+            }
+
             Result.success(
                 BulkSyncResult(
                     playlistCount = playlistResult.size,
@@ -758,7 +828,7 @@ class NavidromeRepository @Inject constructor(
 
     // ─── App Playlist Management ───────────────────────────────────────────
 
-    private suspend fun getAppPlaylistIdForNavidrome(navidromePlaylistId: String): String {
+    private fun getAppPlaylistIdForNavidrome(navidromePlaylistId: String): String {
         return "$NAVIDROME_PLAYLIST_PREFIX$navidromePlaylistId"
     }
 

app/src/main/java/com/theveloper/pixelplay/data/worker/NavidromeSyncWorker.kt

@@ -0,0 +1,81 @@
+package com.theveloper.pixelplay.data.worker
+
+import android.content.Context
+import androidx.hilt.work.HiltWorker
+import androidx.work.CoroutineWorker
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkerParameters
+import androidx.work.workDataOf
+import com.theveloper.pixelplay.data.navidrome.NavidromeRepository
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import timber.log.Timber
+
+@HiltWorker
+class NavidromeSyncWorker @AssistedInject constructor(
+    @Assisted appContext: Context,
+    @Assisted workerParams: WorkerParameters,
+    private val repository: NavidromeRepository
+) : CoroutineWorker(appContext, workerParams) {
+
+    override suspend fun doWork(): Result {
+        val syncType = inputData.getString(KEY_SYNC_TYPE) ?: SYNC_TYPE_ALL
+        val playlistId = inputData.getString(KEY_PLAYLIST_ID)
+
+        Timber.d("NavidromeSyncWorker: Starting sync (type=$syncType, playlistId=$playlistId)")
+
+        return try {
+            when (syncType) {
+                SYNC_TYPE_ALL -> {
+                    repository.syncAllPlaylistsAndSongs { progress, message ->
+                        setProgressAsync(
+                            workDataOf(
+                                PROGRESS_VALUE to progress,
+                                PROGRESS_MESSAGE to message
+                            )
+                        )
+                    }
+                }
+                SYNC_TYPE_PLAYLISTS -> {
+                    repository.syncPlaylists()
+                }
+                SYNC_TYPE_PLAYLIST_SONGS -> {
+                    if (playlistId != null) {
+                        repository.syncPlaylistSongs(playlistId)
+                        repository.syncUnifiedLibrarySongsFromNavidrome()
+                    }
+                }
+            }
+            Result.success()
+        } catch (e: Exception) {
+            Timber.e(e, "NavidromeSyncWorker: Sync failed")
+            Result.failure(workDataOf(ERROR_MESSAGE to e.message))
+        }
+    }
+
+    companion object {
+        const val KEY_SYNC_TYPE = "sync_type"
+        const val KEY_PLAYLIST_ID = "playlist_id"
+        
+        const val SYNC_TYPE_ALL = "all"
+        const val SYNC_TYPE_PLAYLISTS = "playlists"
+        const val SYNC_TYPE_PLAYLIST_SONGS = "playlist_songs"
+
+        const val PROGRESS_VALUE = "progress_value"
+        const val PROGRESS_MESSAGE = "progress_message"
+        const val ERROR_MESSAGE = "error_message"
+
+        fun startAllSync() = OneTimeWorkRequestBuilder<NavidromeSyncWorker>()
+            .setInputData(workDataOf(KEY_SYNC_TYPE to SYNC_TYPE_ALL))
+            .build()
+            
+        fun startPlaylistSync(playlistId: String) = OneTimeWorkRequestBuilder<NavidromeSyncWorker>()
+            .setInputData(
+                workDataOf(
+                    KEY_SYNC_TYPE to SYNC_TYPE_PLAYLIST_SONGS,
+                    KEY_PLAYLIST_ID to playlistId
+                )
+            )
+            .build()
+    }
+}