Add: ReleaseDAO

src/main/kotlin/com/looker/droidify/database/Converters.kt

@@ -2,6 +2,8 @@ package com.looker.droidify.database
 
 import androidx.room.TypeConverter
 import com.looker.droidify.database.entity.Release
+import com.looker.droidify.database.entity.Release.Companion.deserializeIncompatibilities
+import com.looker.droidify.utility.extension.json.writeDictionary
 import com.looker.droidify.utility.jsonGenerate
 import com.looker.droidify.utility.jsonParse
 
@@ -35,8 +37,40 @@ object Converters {
         else string.split(",").map { byteArray.jsonParse { Release.deserialize(it) } }
     }
 
+    @JvmName("releasesToByteArray")
     @TypeConverter
     @JvmStatic
     fun toByteArray(releases: List<Release>) =
         jsonGenerate { releases.forEach { item -> item.serialize(it) }.toString().toByteArray() }
+
+    @TypeConverter
+    @JvmStatic
+    fun toIncompatibilities(byteArray: ByteArray) =
+        byteArray.jsonParse { it.deserializeIncompatibilities() }
+
+    @JvmName("incompatibilitiesToByteArray")
+    @TypeConverter
+    @JvmStatic
+    fun toByteArray(list: List<Release.Incompatibility>) =
+        jsonGenerate { generator ->
+            list.forEach {
+                generator.writeDictionary {
+                    when (it) {
+                        is Release.Incompatibility.MinSdk -> {
+                            writeStringField("type", "minSdk")
+                        }
+                        is Release.Incompatibility.MaxSdk -> {
+                            writeStringField("type", "maxSdk")
+                        }
+                        is Release.Incompatibility.Platform -> {
+                            writeStringField("type", "platform")
+                        }
+                        is Release.Incompatibility.Feature -> {
+                            writeStringField("type", "feature")
+                            writeStringField("feature", it.feature)
+                        }
+                    }::class
+                }
+            }
+        }
 }

src/main/kotlin/com/looker/droidify/database/DAOs.kt

@@ -188,6 +188,17 @@ interface ProductDao : BaseDao<Product> {
     }
 }
 
+@Dao
+interface ReleaseDao : BaseDao<Release> {
+    // This one for the mode combining releases of different sources
+    @Query("SELECT * FROM `release` WHERE packageName = :packageName")
+    fun get(packageName: String): List<Release?>
+
+    // This one for the separating releases of different sources
+    @Query("SELECT * FROM `release` WHERE packageName = :packageName AND signature = :signature")
+    fun get(packageName: String, signature: String): List<Release?>
+}
+
 @Dao
 interface CategoryDao : BaseDao<Category> {
     @get:Query(

src/main/kotlin/com/looker/droidify/database/DatabaseX.kt

@@ -15,17 +15,19 @@ import kotlinx.coroutines.launch
     entities = [
         Repository::class,
         Product::class,
+        Release::class,
         ProductTemp::class,
         Category::class,
         CategoryTemp::class,
         Installed::class,
         Lock::class
-    ], version = 1
+    ], version = 2
 )
 @TypeConverters(Converters::class)
 abstract class DatabaseX : RoomDatabase() {
     abstract val repositoryDao: RepositoryDao
     abstract val productDao: ProductDao
+    abstract val releaseDao: ReleaseDao
     abstract val productTempDao: ProductTempDao
     abstract val categoryDao: CategoryDao
     abstract val categoryTempDao: CategoryTempDao

src/main/kotlin/com/looker/droidify/database/entity/Release.kt

@@ -78,25 +78,7 @@ data class Release(
         generator.writeArray("features") { features.forEach { writeString(it) } }
         generator.writeArray("platforms") { platforms.forEach { writeString(it) } }
         generator.writeArray("incompatibilities") {
-            incompatibilities.forEach {
+            incompatibilities.forEach { serializeIncompatibility(it) }
-                writeDictionary {
-                    when (it) {
-                        is Incompatibility.MinSdk -> {
-                            writeStringField("type", "minSdk")
-                        }
-                        is Incompatibility.MaxSdk -> {
-                            writeStringField("type", "maxSdk")
-                        }
-                        is Incompatibility.Platform -> {
-                            writeStringField("type", "platform")
-                        }
-                        is Incompatibility.Feature -> {
-                            writeStringField("type", "feature")
-                            writeStringField("feature", it.feature)
-                        }
-                    }::class
-                }
-            }
         }
     }
 
@@ -152,24 +134,7 @@ data class Release(
                     it.array("features") -> features = collectNotNullStrings()
                     it.array("platforms") -> platforms = collectNotNullStrings()
                     it.array("incompatibilities") -> incompatibilities =
-                        collectNotNull(JsonToken.START_OBJECT) {
+                        deserializeIncompatibilities()
-                            var type = ""
-                            var feature = ""
-                            forEachKey {
-                                when {
-                                    it.string("type") -> type = valueAsString
-                                    it.string("feature") -> feature = valueAsString
-                                    else -> skipChildren()
-                                }
-                            }
-                            when (type) {
-                                "minSdk" -> Incompatibility.MinSdk
-                                "maxSdk" -> Incompatibility.MaxSdk
-                                "platform" -> Incompatibility.Platform
-                                "feature" -> Incompatibility.Feature(feature)
-                                else -> null
-                            }
-                        }
                     else -> skipChildren()
                 }
             }
@@ -200,5 +165,43 @@ data class Release(
                 incompatibilities
             )
         }
+
+        fun JsonParser.deserializeIncompatibilities() = collectNotNull(JsonToken.START_OBJECT) {
+            var type = ""
+            var feature = ""
+            forEachKey {
+                when {
+                    it.string("type") -> type = valueAsString
+                    it.string("feature") -> feature = valueAsString
+                    else -> skipChildren()
+                }
+            }
+            when (type) {
+                "minSdk" -> Incompatibility.MinSdk
+                "maxSdk" -> Incompatibility.MaxSdk
+                "platform" -> Incompatibility.Platform
+                "feature" -> Incompatibility.Feature(feature)
+                else -> null
+            }
+        }
+
+        fun JsonGenerator.serializeIncompatibility(incompatibility: Incompatibility) =
+            writeDictionary {
+                when (incompatibility) {
+                    is Incompatibility.MinSdk -> {
+                        writeStringField("type", "minSdk")
+                    }
+                    is Incompatibility.MaxSdk -> {
+                        writeStringField("type", "maxSdk")
+                    }
+                    is Incompatibility.Platform -> {
+                        writeStringField("type", "platform")
+                    }
+                    is Incompatibility.Feature -> {
+                        writeStringField("type", "feature")
+                        writeStringField("feature", incompatibility.feature)
+                    }
+                }::class
+            }
     }
 }