Merge branch 'feature/server-database' into develop

app/build.gradle

@@ -38,6 +38,7 @@ android {
 }
 
 dependencies {
+    def room_version = "2.3.0"
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation 'androidx.core:core-ktx:1.5.0'
@@ -47,6 +48,11 @@ dependencies {
     implementation 'androidx.legacy:legacy-support-v4:1.0.0'
     implementation 'androidx.navigation:navigation-fragment-ktx:2.3.5'
     implementation 'androidx.navigation:navigation-ui-ktx:2.3.5'
+
+    implementation "androidx.room:room-runtime:$room_version"
+    kapt "androidx.room:room-compiler:$room_version"
+    implementation "androidx.room:room-ktx:$room_version"
+
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.2'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

app/src/main/java/dev/jdtech/jellyfin/database/Server.kt

@@ -1,9 +1,15 @@
 package dev.jdtech.jellyfin.database
 
-import java.util.*
+import androidx.room.Entity
+import androidx.room.PrimaryKey
 
+@Entity(tableName = "servers")
 data class Server(
-    val id: UUID,
+    @PrimaryKey
+    val id: String,
     val name: String,
-    val address: String
+    val address: String,
+    val userId: String,
+    val userName: String,
+    val accessToken: String,
 )

app/src/main/java/dev/jdtech/jellyfin/database/ServerDatabase.kt

@@ -0,0 +1,32 @@
+package dev.jdtech.jellyfin.database
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+@Database(entities = [Server::class], version = 1, exportSchema = false)
+abstract class ServerDatabase : RoomDatabase() {
+    abstract val serverDatabaseDao: ServerDatabaseDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: ServerDatabase? = null
+
+        fun getInstance(context: Context): ServerDatabase {
+            synchronized(this) {
+                var instance = INSTANCE
+                if (instance == null) {
+                    instance = Room.databaseBuilder(
+                        context.applicationContext,
+                        ServerDatabase::class.java,
+                        "servers"
+                    )
+                        .fallbackToDestructiveMigration().build()
+                    INSTANCE = instance
+                }
+                return instance
+            }
+        }
+    }
+}

app/src/main/java/dev/jdtech/jellyfin/database/ServerDatabaseDao.kt

@@ -0,0 +1,28 @@
+package dev.jdtech.jellyfin.database
+
+import androidx.lifecycle.LiveData
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.Query
+import androidx.room.Update
+
+@Dao
+interface ServerDatabaseDao {
+    @Insert
+    fun insert(server: Server)
+
+    @Update
+    fun update(server: Server)
+
+    @Query("select * from servers where id = :id")
+    fun get(id: String): Server
+
+    @Query("delete from servers")
+    fun clear()
+
+    @Query("select * from servers")
+    fun getAllServers(): LiveData<List<Server>>
+
+    @Query("delete from servers where id = :id")
+    fun delete(id: String)
+}

app/src/main/java/dev/jdtech/jellyfin/serverselect/ServerSelectFragment.kt

@@ -8,6 +8,7 @@ import android.view.ViewGroup
 import androidx.lifecycle.ViewModelProvider
 import androidx.navigation.fragment.findNavController
 import dev.jdtech.jellyfin.R
+import dev.jdtech.jellyfin.database.ServerDatabase
 import dev.jdtech.jellyfin.databinding.FragmentServerSelectBinding
 
 
@@ -18,7 +19,12 @@ class ServerSelectFragment : Fragment() {
     ): View? {
         val binding = FragmentServerSelectBinding.inflate(inflater)
 
-        val viewModel = ViewModelProvider(this).get(ServerSelectViewModel::class.java)
+        val application = requireNotNull(this.activity).application
+
+        val dataSource = ServerDatabase.getInstance(application).serverDatabaseDao
+
+        val viewModelFactory = ServerSelectViewModelFactory(dataSource)
+        val viewModel = ViewModelProvider(this, viewModelFactory).get(ServerSelectViewModel::class.java)
 
         binding.lifecycleOwner = this
         binding.viewModel = viewModel

app/src/main/java/dev/jdtech/jellyfin/serverselect/ServerSelectViewModel.kt

@@ -1,19 +1,45 @@
 package dev.jdtech.jellyfin.serverselect
 
 import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import dev.jdtech.jellyfin.database.Server
-import java.util.*
+import dev.jdtech.jellyfin.database.ServerDatabaseDao
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
-class ServerSelectViewModel : ViewModel() {
-    private val _servers = MutableLiveData<List<Server>>()
+class ServerSelectViewModel(
+    val database: ServerDatabaseDao,
+) : ViewModel() {
+    private val _servers = database.getAllServers()
     val servers: LiveData<List<Server>>
         get() = _servers
 
     init {
-        val server = Server(UUID.randomUUID(), "JDTech", "https://jellyfin.jdtech.dev")
-        val demoServer = Server(UUID.randomUUID(), "Demo", "https://demo.jellyfin.org")
-        _servers.value = listOf(server, demoServer)
+        val demoServer = Server("0", "Demo", "https://demo.jellyfin.org", "0", "demo", "")
+
+        viewModelScope.launch {
+            clearDatabase()
+            insert(demoServer)
+        }
+    }
+
+    private suspend fun insert(server: Server) {
+        withContext(Dispatchers.IO) {
+            database.insert(server)
+        }
+    }
+
+    private suspend fun delete(server: Server) {
+        withContext(Dispatchers.IO) {
+            database.delete(server.id)
+        }
+    }
+
+    private suspend fun clearDatabase() {
+        withContext(Dispatchers.IO) {
+            database.clear()
+        }
     }
 }

app/src/main/java/dev/jdtech/jellyfin/serverselect/ServerSelectViewModelFactory.kt

@@ -0,0 +1,17 @@
+package dev.jdtech.jellyfin.serverselect
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import dev.jdtech.jellyfin.database.ServerDatabaseDao
+import java.lang.IllegalArgumentException
+
+class ServerSelectViewModelFactory(
+    private val dataSource: ServerDatabaseDao
+    ) : ViewModelProvider.Factory {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+        if (modelClass.isAssignableFrom(ServerSelectViewModel::class.java)) {
+            return ServerSelectViewModel(dataSource) as T
+        }
+        throw IllegalArgumentException("Unknown ViewModel class")
+    }
+}