【Kotlin/Android Studio】DataStoreの使い方！データの保存と取得方法

dependencies {
    // 〜〜〜〜〜〜〜〜〜〜〜
    implementation("androidx.datastore:datastore-preferences:1.1.4")
}

dependencies {
    // 〜〜〜〜〜〜〜〜〜〜〜
    implementation("androidx.datastore:datastore:1.1.4")
}

DataStoreExtensions.kt
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.preferencesDataStore
import androidx.datastore.preferences.core.Preferences

val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")

DataStoreExtensions.kt
Property delegate must have a 'getValue(Context, KProperty<*>)' method. None of the following functions is suitable: 
public abstract operator fun getValue(thisRef: Context, property: KProperty<*>): DataStore<Preferences> defined in kotlin.properties.ReadOnlyProperty

DataStoreExtensions.kt
val EXAMPLE_COUNTER = intPreferencesKey("example_counter")

MainActivity.kt
suspend fun incrementCounter() {
    applicationContext.dataStore.edit { settings ->
        val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0
        settings[EXAMPLE_COUNTER] = currentCounterValue + 1
    }
}

MainActivity.kt
val addButton:Button = findViewById(R.id.add_button)
val getButton:Button = findViewById(R.id.get_button)

addButton.setOnClickListener{
    GlobalScope.launch (Dispatchers.IO) {
        incrementCounter()
    }
}

public fun getCounter(): Int {
    return runBlocking {
        context.dataStore.data
            .catch { exception ->
                if (exception is IOException) {
                    // 空の値を返す
                    emit(emptyPreferences())  
                } else {
                     // その他の例外は再スロー
                    throw exception 
                }
            }
            .firstOrNull()
            ?.get(EXAMPLE_COUNTER) ?: 0
    }
}

val exampleCounterFlow: Flow<Int> = dataStore.data
    .catch { exception ->
        if (exception is IOException) {
            emit(emptyPreferences())
        } else {
            throw exception
        }
    }.map { preferences ->
        preferences[EXAMPLE_COUNTER] ?: 0
    }

MainActivity.kt
suspend fun getCounter() {
    val text:TextView = findViewById(R.id.activity_text)
    val exampleCounterFlow: Flow<Int> = dataStore.data
        .catch { exception ->
            if (exception is IOException) {
                emit(emptyPreferences())
            } else {
                throw exception
            }
        }
        .map { preferences ->
            preferences[EXAMPLE_COUNTER] ?: 0
        }

    text.text = exampleCounterFlow.first().toString()
}

MainActivity.kt
val getButton:Button = findViewById(R.id.get_button)

getButton.setOnClickListener{
    runBlocking {
        getCounter()
    }
}

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.emptyPreferences
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.io.IOException

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val addButton:Button = findViewById(R.id.add_button)
        val getButton:Button = findViewById(R.id.get_button)

        addButton.setOnClickListener{
            GlobalScope.launch (Dispatchers.IO) {
                incrementCounter()
            }
        }
        getButton.setOnClickListener{
            runBlocking {
                getCounter()
            }
        }

    }

    suspend fun incrementCounter() {
        applicationContext.dataStore.edit { settings ->
            val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0
            settings[EXAMPLE_COUNTER] = currentCounterValue + 1
        }
    }

    suspend fun getCounter() {
        val text:TextView = findViewById(R.id.activity_text)
        val exampleCounterFlow: Flow<Int> = dataStore.data
            .catch { exception ->
                if (exception is IOException) {
                    emit(emptyPreferences())
                } else {
                    throw exception
                }
            }
            .map { preferences ->
                preferences[EXAMPLE_COUNTER] ?: 0
            }

        text.text = exampleCounterFlow.first().toString()
    }
}

class DataStoreManager(private val context: Context) {

    companion object {
        val CURRENT_USER = stringPreferencesKey("current_user")
    }

    suspend fun saveCurrentUser(currentUser: String) {
        try {
            context.dataStore.edit { preferences ->
                preferences[CURRENT_USER] = currentUser
            }
        } catch (e: IOException) {
            print("例外が発生したよ")
        }
    }

    public fun observeCurrentUser(): Flow<String?> {
        return context.dataStore.data.catch { exception ->
            if (exception is IOException) {
                emit(emptyPreferences())
            } else {
                throw exception
            }
        }.map { preferences ->
            preferences[CURRENT_USER]
        }
    }
}

  val dataStoreManager = DataStoreManager(this)
    
button.setOnClickListener {
    runBlocking(Dispatchers.IO) {
        dataStoreManager.saveCurrentUser(editText.text.toString())
    }
}

lifecycleScope.launch{
    // CURRENT_USERを観察し、変更があれば自動更新されるようにする
    dataStoreManager.observeCurrentUser().collect {
        text.text =  it.toString()
    }
}

val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")

Property delegate must have a 'getValue(Context, KProperty<*>)' method. None of the following functions is suitable: 
public abstract operator fun getValue(thisRef: Context, property: KProperty<*>): DataStore<Preferences> defined in kotlin.properties.ReadOnlyProperty

import androidx.datastore.preferences.core.Preferences // ○
import java.util.prefs.Preferences // ×

No type arguments expected for class Flow

//import kotlinx.coroutines.flow.Flow // ○
  
import java.util.concurrent.Flow // ×