Feature/issue 42 local storage encryption

gradle/libs.versions.toml

@@ -9,10 +9,12 @@ compileSdk = "34"
 composeBom = "2024.05.00"
 composeNavigation = "2.8.0-alpha08"
 coreKtx = "1.13.1"
+coreKtxVersion = "1.5.0"
 coreTestingVersion = "2.2.0"
 coroutinesVersion = "1.8.0"
-credentialsPlayServicesAuth = "1.2.2"
+datastorePreferences = "1.1.1"
 detekt = "1.23.6" # please adjust github action version as well in case of version change
+credentialsPlayServicesAuth = "1.2.2"
 dokka = "1.9.20"
 espressoCore = "3.5.1"
 firebaseAuthKtx = "23.0.0"
@@ -38,6 +40,7 @@ mockKVersion = "1.13.10"
 playServicesAuth = "21.2.0"
 rulesVersion = "1.5.0"
 runnerVersion = "1.5.2"
+securityCryptoKtx = "1.1.0-alpha06"
 targetSdk = "34"
 testCoreVersion = "1.5.0"
 timberVersion = "5.0.1"
@@ -54,6 +57,7 @@ androidx-health-connect-client = { module = "androidx.health.connect:connect-cli
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
 androidx-core-testing = { group = "androidx.arch.core", name = "core-testing", version.ref = "coreTestingVersion" }
 androidx-credentials-play-services-auth = { module = "androidx.credentials:credentials-play-services-auth", version.ref = "credentialsPlayServicesAuth" }
+androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
 androidx-foundation = { module = "androidx.compose.foundation:foundation", version.ref = "foundation" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
@@ -62,6 +66,7 @@ androidx-lifecycle-view-model-ktx = { group = "androidx.lifecycle", name = "life
 androidx-test-core = { group = "androidx.test", name = "core", version.ref = "testCoreVersion" }
 androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "runnerVersion" }
 androidx-test-rules = { group = "androidx.test", name = "rules", version.ref = "rulesVersion" }
+androidx-security-crypto-ktx = { group = "androidx.security", name = "security-crypto-ktx", version.ref = "securityCryptoKtx" }
 compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
 compose-material3 = { group = "androidx.compose.material3", name = "material3" }
 compose-runtime = { group = "androidx.compose.runtime", name = "runtime" }
@@ -71,6 +76,7 @@ compose-ui-test = { group = "androidx.compose.ui", name = "ui-test-junit4" }
 compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
 compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
 compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+core-ktx = { group = "androidx.test", name = "core-ktx", version.ref = "coreKtxVersion" }
 coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutinesVersion" }
 coroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "coroutinesVersion" }
 coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesVersion" }

modules/storage/.gitignore

@@ -0,0 +1 @@
+/build

modules/storage/README.MD

@@ -0,0 +1,80 @@
+# Module storage
+
+The storage module provides components for managing storage in your application. It includes classes
+for handling key-value/file storage and secure storage of data.
+
+## Usage
+
+To use the Storage module in your project, add the following dependency to your `build.gradle` file:
+
+```gradle
+dependencies {
+    implementation(":core:storage")`
+}
+```
+
+and provide the wanted storage implementation with Hilt DI. There are the following storage
+implementations:
+
+- `EncryptedFileStorage` for the `FileStorage` interface
+- `EncryptedSharedPreferencesStorage` for the `KeyValueStorage` interface
+- `LocalStorage` for the `KeyValueStorage` interface
+
+## Key-Value Storage
+
+The key-value storage provides a simple interface for storing and retrieving key-value pairs:
+
+```kotlin
+interface KeyValueStorage {
+    suspend fun <T : Any> saveData(key: PreferenceKey<T>, data: T)
+    fun <T> readData(key: PreferenceKey<T>): Flow<T?>
+    suspend fun <T> readDataBlocking(key: PreferenceKey<T>): T?
+    suspend fun <T> deleteData(key: PreferenceKey<T>)
+}
+```
+
+It can be used like this:
+
+```kotlin
+val stringKey = PreferenceKey.StringKey("user_name")
+keyValueStorage.saveData(stringKey, "test_user_name")
+keyValueStorage.readDataBlocking(stringKey)?.let {
+    println("Read string data blocking: $it")
+}
+keyValueStorage.deleteData(stringKey)
+```
+
+or you can use the `Flow` interface to observe changes:
+
+```kotlin
+val job = launch {
+    keyValueStorage.readData(stringKey).collect { data: String? ->
+        println("Read string data: $data")
+    }
+}
+```
+
+## File Storage
+
+The file storage provides a simple interface for storing and retrieving files:
+
+```kotlin
+interface FileStorage {
+    suspend fun readFile(fileName: String): ByteArray?
+    suspend fun deleteFile(fileName: String)
+    suspend fun saveFile(fileName: String, data: ByteArray)
+}
+```
+
+It can be used like this:
+
+```kotlin
+val fileName = "testFile.data"
+val data = "Hello, Stanford!".toByteArray()
+fileStorage.saveFile(fileName, data)
+val readData = fileStorage.readFile(fileName)
+readData?.let {
+    println("Read file data: ${String(it)}")
+}
+fileStorage.deleteFile(fileName)
+```

modules/storage/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    alias(libs.plugins.spezi.library)
+    alias(libs.plugins.spezi.hilt)
+}
+
+android {
+    namespace = "edu.stanford.spezi.modules.storage"
+}
+
+dependencies {
+    androidTestImplementation(libs.bundles.compose.androidTest)
+
+    androidTestImplementation(project(":core:testing"))
+
+    implementation(project(":core:coroutines"))
+
+    implementation(libs.androidx.datastore.preferences)
+    implementation(libs.androidx.security.crypto.ktx)
+    implementation(libs.core.ktx)
+
+    implementation(project(":core:utils"))
+
+    testImplementation(libs.bundles.unit.testing)
+
+    testImplementation(project(":core:testing"))
+}

modules/storage/src/androidTest/kotlin/edu/stanford/spezi/modules/storage/file/EncryptedFileKeyValueStorageTest.kt

@@ -0,0 +1,77 @@
+package edu.stanford.spezi.modules.storage.file
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import edu.stanford.spezi.core.testing.runTestUnconfined
+import kotlinx.coroutines.Dispatchers
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EncryptedFileKeyValueStorageTest {
+    private var context: Context = ApplicationProvider.getApplicationContext()
+    private var fileStorage: FileStorage =
+        EncryptedFileStorage(
+            context = context,
+            ioDispatcher = Dispatchers.Unconfined,
+        )
+
+    @Test
+    fun `it should save and read file correctly`() = runTestUnconfined {
+        // Given
+        val fileName = "testFile"
+        val data = "Hello, World!".toByteArray()
+
+        // When
+        fileStorage.saveFile(fileName, data)
+
+        // Then
+        val readData = fileStorage.readFile(fileName)
+        assertThat(readData).isEqualTo(data)
+    }
+
+    @Test
+    fun `it should return null when reading non-existent file`() = runTestUnconfined {
+        // Given
+        val fileName = "nonExistentFile"
+
+        // When
+        val readData = fileStorage.readFile(fileName)
+
+        // Then
+        assertThat(readData).isNull()
+    }
+
+    @Test
+    fun `it should overwrite existing file when saving with same filename`() = runTestUnconfined {
+        // Given
+        val fileName = "testFile"
+        val initialData = "Hello, World!".toByteArray()
+        val newData = "New data".toByteArray()
+
+        // When
+        fileStorage.saveFile(fileName, initialData)
+        fileStorage.saveFile(fileName, newData)
+
+        // Then
+        val readData = fileStorage.readFile(fileName)
+        assertThat(readData).isEqualTo(newData)
+    }
+
+    @Test
+    fun `it should delete file correctly`() = runTestUnconfined {
+        // Given
+        val fileName = "testFile"
+        val data = "Hello, World!".toByteArray()
+        fileStorage.saveFile(fileName, data)
+
+        // When
+        fileStorage.deleteFile(fileName)
+
+        // Then
+        val readData = fileStorage.readFile(fileName)
+        assertThat(readData).isNull()
+    }
+}