rewrite

Author: krizzu

samples/android/src/main/java/com/asyncstorage/sqlite/android/example/MainActivity.kt

@@ -4,15 +4,14 @@ import android.os.Bundle
 import androidx.activity.compose.setContent
 import androidx.appcompat.app.AppCompatActivity
 import com.asyncstorage.sqlite.android.example.ui.MainScreen
-import org.asyncstorage.sqlitestorage.SQLiteStorageFactory
 import org.asyncstorage.sqlitestorage.SqliteStorage
 
 class MainActivity : AppCompatActivity() {
     lateinit var db: SqliteStorage
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        db = SQLiteStorageFactory(this).create("my_db")
+        db = StorageFactory(this).create("my_db")
         setContent {
             MainScreen(db)
         }

sqlite-storage/build.gradle.kts

@@ -23,6 +23,18 @@ kotlin {
         }
     }
 
+
+
+    // disable expect-actual warning
+    targets.all {
+        compilations.all {
+            compilerOptions.configure {
+                freeCompilerArgs.add("-Xexpect-actual-classes")
+            }
+        }
+    }
+
+
     jvmToolchain(11)
 
     sourceSets {

sqlite-storage/src/androidMain/kotlin/org/asyncstorage/sqlitestorage/AndroidDatabaseFile.kt

@@ -0,0 +1,33 @@
+package org.asyncstorage.sqlitestorage
+
+import java.io.File
+
+internal class AndroidDatabaseFile(private val dbFile: File) : DatabaseFile {
+    override fun path(): String = dbFile.absolutePath
+
+    override fun dirPath(): String = dbFile.parentFile!!.absolutePath
+
+    override fun delete(): Boolean {
+        val dbName = dbFile.name
+        return try {
+            val parent = dbFile.parentFile!!
+            val deleted = mutableListOf<Boolean>()
+
+            listOf(dbName, "$dbName-wal", "$dbName-shm").forEach { dbFile ->
+                deleted += File(parent, dbFile).delete()
+            }
+            true
+        } catch (e: SecurityException) {
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    override fun size(): Long {
+        var size = -1L
+        if (dbFile.exists()) {
+            size = (dbFile.length() / 1024L)
+        }
+        return size
+    }
+}

sqlite-storage/src/androidMain/kotlin/org/asyncstorage/sqlitestorage/SQLiteStorageFactory.kt

@@ -0,0 +1,45 @@
+package org.asyncstorage.sqlitestorage
+
+import android.content.Context
+import androidx.sqlite.db.SupportSQLiteDatabase
+import app.cash.sqldelight.driver.android.AndroidSqliteDriver
+import org.asyncstorage.sqlitestorage.db.AsyncStorageDB
+
+actual class SqliteStorageFactory(private val ctx: Context) {
+    actual fun create(dbName: String): SqliteStorage {
+        val driver = createDriver(dbName)
+        val dbUtils = AndroidDatabaseFile(ctx.getDatabasePath(dbName))
+        return SqliteStorage(
+            driver = driver,
+            dbFile = dbUtils,
+        )
+    }
+
+    private fun createDriver(dbName: String): AndroidSqliteDriver {
+        val callback =
+            object : AndroidSqliteDriver.Callback(AsyncStorageDB.Schema) {
+                override fun onConfigure(db: SupportSQLiteDatabase) {
+                    /**
+                     * Makes this database work in Write-ahead log journal mode
+                     * Available for SQLite version 3.7.0 (2010-07-21) or later
+                     * Android supports 3.7.0+ since API 11 (https://developer.android.com/reference/android/database/sqlite/package-summary)
+                     */
+                    db.enableWriteAheadLogging()
+                    /**
+                     * Makes sqlite use Normal mode for synchronizing DB content with filesystem only in crucial times
+                     * WAL file is synchronized before each checkpoint and the database file is synchronized after each completed checkpoint
+                     *
+                     * https://sqlite.org/pragma.html#pragma_synchronous
+                     */
+                    db.execSQL("PRAGMA synchronous = NORMAL")
+                }
+            }
+
+        return AndroidSqliteDriver(
+            schema = AsyncStorageDB.Schema,
+            context = ctx,
+            name = dbName,
+            callback = callback,
+        )
+    }
+}

sqlite-storage/src/androidMain/kotlin/org/asyncstorage/sqlitestorage/SqliteStorageFactory.android.kt

@@ -1,22 +1,23 @@
 package org.asyncstorage.sqlitestorage
 
+import android.content.Context
 import androidx.test.core.app.ApplicationProvider
-import org.asyncstorage.sqlitestorage.utils.DatabaseUtils
 import org.asyncstorage.sqlitestorage.utils.JunitRunner
 import org.junit.Test
 import org.junit.runner.RunWith
 
-internal actual fun createUtils(name: String): DatabaseUtils {
-    return DatabaseUtils(name, ApplicationProvider.getApplicationContext())
+internal actual fun createDatabaseFile(name: String): DatabaseFile {
+    val ctx: Context = ApplicationProvider.getApplicationContext()
+    return AndroidDatabaseFile(ctx.getDatabasePath(name))
 }
 
 @RunWith(JunitRunner::class)
-class AndroidDbUtilsTest {
+class AndroidDatabaseFileTest {
     @Test
     fun `correct database path is returned`() {
         val dbName = "testing_my_db.db"
-        val utils = createUtils(dbName)
-        val dbPath = utils.getDbFilePath()
+        val file = createDatabaseFile(dbName)
+        val dbPath = file.path()
         val expected = "databases/$dbName"
         assert(dbPath.endsWith("databases/$dbName")) {
             "db path not matching, expected: $expected, received: $dbPath"

sqlite-storage/src/androidMain/kotlin/org/asyncstorage/sqlitestorage/utils/DatabaseUtils.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import app.cash.sqldelight.driver.android.AndroidSqliteDriver
 import kotlinx.coroutines.CoroutineDispatcher
+import org.asyncstorage.sqlitestorage.AndroidDatabaseFile
 import org.asyncstorage.sqlitestorage.DefaultSqliteStorage
 import org.asyncstorage.sqlitestorage.SqliteStorage
 import org.asyncstorage.sqlitestorage.db.AsyncStorageDB
@@ -15,6 +16,6 @@ actual fun createTestDatabase(
     val ctx = ApplicationProvider.getApplicationContext<Context>()
     // passing name as null to SupportSQLiteOpenHelper creates in-memory db
     val driver = AndroidSqliteDriver(AsyncStorageDB.Schema, ctx, null)
-    val dbUtils = DatabaseUtils(dbName, ctx)
-    return DefaultSqliteStorage(driver, dbUtils, dispatcher, dispatcher)
+    val dbUtils = AndroidDatabaseFile(ctx.getDatabasePath(dbName))
+    return DefaultSqliteStorage(driver, dbUtils, dispatcher)
 }

sqlite-storage/src/androidUnitTest/kotlin/org/asyncstorage/sqlitestorage/DbUtilsTest.kt renamed to sqlite-storage/src/androidUnitTest/kotlin/org/asyncstorage/sqlitestorage/DatabaseFileTest.android.kt

@@ -0,0 +1,26 @@
+package org.asyncstorage.sqlitestorage
+
+interface DatabaseFile {
+    /**
+     * Returns an absolute path to main .db file
+     */
+    fun path(): String
+
+    /**
+     * An absolute path to a directory containing database files
+     */
+    fun dirPath(): String
+
+    /**
+     * Removes the database file and all related WAL files (-wal and -shm).
+     */
+    fun delete(): Boolean
+
+    /**
+     * Returns database file size in KB.
+     * If file does not exists or cannot be reached due to security returns 0.
+     * This only checks the size of main database file, without log file (-wal) or wal-index file (-shm)
+     * To get the correct values, call this after manual WAL checkpoint.
+     */
+    fun size(): Long
+}

sqlite-storage/src/androidUnitTest/kotlin/org/asyncstorage/sqlitestorage/utils/CreateTestDb.kt

@@ -7,36 +7,22 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.withContext
 import org.asyncstorage.sqlitestorage.db.AsyncStorageDB
+import org.asyncstorage.sqlitestorage.dispatchers.DispatcherIO
 import org.asyncstorage.sqlitestorage.extensions.executePragmaOptimize
-import org.asyncstorage.sqlitestorage.extensions.executePragmaSyncNormal
 import org.asyncstorage.sqlitestorage.extensions.executePragmaWalCheckpoint
-import org.asyncstorage.sqlitestorage.extensions.executePragmaWalJournalMode
 import org.asyncstorage.sqlitestorage.models.Entry
 import org.asyncstorage.sqlitestorage.models.Key
-import org.asyncstorage.sqlitestorage.utils.DatabaseUtils
 import org.asyncstorage.sqlitestorage.utils.mergePossibleJsonValues
 
 internal class DefaultSqliteStorage(
     private val driver: SqlDriver,
-    private val dbUtils: DatabaseUtils,
-    private val readDispatcher: CoroutineDispatcher,
-    private val writeDispatcher: CoroutineDispatcher,
+    private val dbFile: DatabaseFile,
+    private val dispatcher: CoroutineDispatcher = DispatcherIO,
 ) : SqliteStorage {
     private val queries = AsyncStorageDB(driver).async_storage_entriesQueries
 
-    init {
-        /**
-         * Makes this database work in Write-ahead log journal mode
-         * Available for SQLite version 3.7.0 (2010-07-21) or later
-         * Android supports 3.7.0+ since API 11 (https://developer.android.com/reference/android/database/sqlite/package-summary)
-         * iOS supports 3.7.0+ since iOS 4.3.x (https://www.theiphonewiki.com/wiki/Databases)
-         */
-        driver.executePragmaWalJournalMode()
-        driver.executePragmaSyncNormal()
-    }
-
     override suspend fun read(key: Key): Entry =
-        withContext(readDispatcher) {
+        withContext(dispatcher) {
             queries.getOne(key) { k, v -> Entry(k, v) }.executeAsOneOrNull() ?: Entry(key)
         }
 
@@ -49,12 +35,12 @@ internal class DefaultSqliteStorage(
     }
 
     override suspend fun write(entry: Entry) =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.insertOne(entry.key, entry.value)
         }
 
     override suspend fun merge(entry: Entry) =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.transactionWithResult {
                 val current = queries.getOne(entry.key).executeAsOneOrNull()
                 if (current == null) {
@@ -69,12 +55,12 @@ internal class DefaultSqliteStorage(
         }
 
     override suspend fun remove(key: Key) =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.deleteOne(key)
         }
 
     override suspend fun readMany(keys: List<Key>): List<Entry> =
-        withContext(readDispatcher) {
+        withContext(dispatcher) {
             val found = queries.getMany(keys) { k, v -> Entry(k, v) }.executeAsList()
             keys.map { key ->
                 found.find { it.key == key } ?: Entry(key)
@@ -93,7 +79,7 @@ internal class DefaultSqliteStorage(
     }
 
     override suspend fun writeMany(entries: List<Entry>) =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.transaction {
                 entries.forEach { entry ->
                     queries.insertOne(entry.key, entry.value)
@@ -102,7 +88,7 @@ internal class DefaultSqliteStorage(
         }
 
     override suspend fun mergeMany(entries: List<Entry>) =
-        withContext<List<Entry>>(writeDispatcher) {
+        withContext<List<Entry>>(dispatcher) {
             queries.transactionWithResult {
                 val result = mutableListOf<Entry>()
                 for (entry in entries) {
@@ -121,17 +107,17 @@ internal class DefaultSqliteStorage(
         }
 
     override suspend fun removeMany(keys: List<Key>) =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.deleteMany(keys)
         }
 
     override suspend fun clear() =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             queries.deleteAll()
         }
 
     override suspend fun getKeys(): List<Key> =
-        withContext(readDispatcher) {
+        withContext(dispatcher) {
             queries.getAllKeys().executeAsList()
         }
 
@@ -144,22 +130,22 @@ internal class DefaultSqliteStorage(
     }
 
     override suspend fun closeConnection() =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             driver.executePragmaOptimize()
             driver.close()
         }
 
-    override fun getDbPath() = dbUtils.getDbFilePath()
+    override fun getDbPath() = dbFile.path()
 
     override suspend fun getDbSize(): Long =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             driver.executePragmaWalCheckpoint()
-            dbUtils.getDbFileSize()
+            dbFile.size()
         }
 
     override suspend fun dropDatabase() =
-        withContext(writeDispatcher) {
+        withContext(dispatcher) {
             driver.close()
-            dbUtils.removeDbFiles()
+            dbFile.delete()
         }
 }