2023-2024/Lab/Moduł3/Lab10/10.2.1 DataStore Basics - Compose.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "baa8af71-9743-4121-88cb-2f910c6dd862",
   "metadata": {},
   "source": [
    "# Jetpack Compose - DataStore - Podstawy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bea97ae-f124-4b17-8081-3f571a5794c0",
   "metadata": {},
   "source": [
    "W tej aplikacji przyjrzymy się zastosowaniu **DataStore** w celu zapisania niewielkich ilości danych w pliku."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12ce465f-a159-4d22-842f-0f3022d00dbf",
   "metadata": {},
   "source": [
    "<img src=\"https://media0.giphy.com/media/v1.Y2lkPTc5MGI3NjExMHZ0Mmt6cjJwYjVrYzE0NWdpbHNqYXM5ZjVvNzc1bmhqZm1zY2F5NSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/kd4nprniMKNt9fBZIv/giphy.gif\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32c4eedf-c867-4158-b6ea-f364f860def8",
   "metadata": {},
   "source": [
    "Jest to biblioteka, która pomaga w przechowywaniu i zarządzaniu danymi w sposób bardziej zoptymalizowany i bezpieczny niż starsze rozwiązania, takie jak `SharedPreferences` (zostanie omówiony w kolejnym przykładzie).\n",
    "\n",
    "`DataStore` jest często wykorzystywany do przechowywania niewielkich ilości danych, takich jak preferencje użytkownika, ustawienia aplikacji, stan sesji i tym podobne. Nie jest on jednak odpowiedni do przechowywania dużej ilości danych, jakie można znaleźć w bazach danych.\n",
    "\n",
    "Oferuje dwa główne rodzaje implementacji:\n",
    "- `Preferences DataStore` - Ten rodzaj jest podobny do `SharedPreferences`, ale jest oparty na protokole `Kotlin Coroutines` i zapewnia bezpieczne przechowywanie danych. Można w nim przechowywać dane w postaci *klucz-wartość*, gdzie klucze są ciągami znaków, a wartości mogą być różnymi typami danych, takimi jak liczby, ciągi znaków itp.\n",
    "- `Proto DataStore` - Ten rodzaj pozwala na zapisywanie danych w formacie `protobuf`. Jest to format serializacji danych opracowany przez firmę Google.\n",
    "\n",
    "Główne cehy korzystania z `DataStore` to:\n",
    "- Wsparcie dla asynchronicznych operacji dzięki `Kotlin Coroutines`.\n",
    "- Bezpieczeństwo wątkowe - unika problemów synchronizacyjnych, które mogą występować w przypadku `SharedPreferences`.\n",
    "- Automatyczne obsługiwania zmian wartości, co pozwala na łatwe reagowanie na zmiany danych.\n",
    "- Możliwość zapisywania i odczytywania niestandardowych typów danych dzięki `Protobuf`.\n",
    "\n",
    "W przykładowej aplikacji wykorzystamy `DataStore` do zapisania i odczytania nazwy użytkownika.\n",
    "\n",
    "Dodajmy niezbędne zależności do projektu:\n",
    "\n",
    "```kotlin\n",
    "implementation (\"androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1\")\n",
    "implementation (\"androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1\")\n",
    "implementation (\"androidx.lifecycle:lifecycle-runtime-compose:2.6.1\")\n",
    "\n",
    "implementation (\"androidx.datastore:datastore-preferences:1.0.0\")\n",
    "```\n",
    "\n",
    "Chcemy dodawać nazwy użytkowników, podobnie jak w poprzednich przykładach dodajmy *dummydata* w celu ułatwienia generacji przykładowych nazw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba4046c-79d6-4fe1-932d-850936a17eca",
   "metadata": {},
   "outputs": [],
   "source": [
    "object DataProvider {\n",
    "\n",
    "    private val usernames = listOf(\n",
    "        \"CoolDude123\",\n",
    "        \"SuperStar\",\n",
    "        \"GamerGirl99\",\n",
    "        \"TechMaster\",\n",
    "        \"MusicLover\",\n",
    "        \"FitnessFreak\",\n",
    "        \"Traveler_21\",\n",
    "        \"FoodieQueen\",\n",
    "        \"NatureLover\",\n",
    "        \"Fashionista\",\n",
    "        \"Bookworm42\",\n",
    "        \"MovieBuff\",\n",
    "        \"AdventureSeeker\",\n",
    "        \"PetLover_87\",\n",
    "        \"SportsFanatic\",\n",
    "        \"ArtisticSoul\",\n",
    "        \"StarGazer\",\n",
    "        \"YogaEnthusiast\",\n",
    "        \"PhotographyPro\",\n",
    "        \"DreamChaser\",\n",
    "        \"BeachBum123\",\n",
    "        \"CoffeeAddict\",\n",
    "        \"GameChanger\",\n",
    "        \"LaughOutLoud\",\n",
    "        \"MindfulSoul\",\n",
    "        \"HappyGoLucky\",\n",
    "        \"TechGeek1\",\n",
    "        \"FoodExplorer\",\n",
    "        \"FitnessJunkie\"\n",
    "    )\n",
    "\n",
    "    val username: String\n",
    "        get() = usernames.random()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c67b4a38-bedf-4c95-ab8b-351b727a04da",
   "metadata": {},
   "source": [
    "Dodajmy klasę pomocniczą `SaveUsernameDataStore`, która służy do przechowywania i pobierania nazwy użytkownika przy użyciu `DataStore`. Wykorzystamy wzorzec Singleton, ponieważ chcemy posiadać tylko jeden obiekt przez który będziemy komunikowac się z `DataStore`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9f29d13-5afa-4145-a79f-de5270cfd644",
   "metadata": {},
   "outputs": [],
   "source": [
    "object SaveUsernameDataStore {\n",
    "    private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(\"user_prefs\")\n",
    "    private val USERNAME_KEY = stringPreferencesKey(\"USERNAME\")\n",
    "\n",
    "    suspend fun storeUsername(context: Context, username: String) {\n",
    "        context.dataStore.edit { preferences ->\n",
    "            preferences[USERNAME_KEY] = username\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fun getUsernameFlow(context: Context): Flow<String> {\n",
    "        return context.dataStore.data.map { preferences ->\n",
    "            preferences[USERNAME_KEY] ?: \"\"\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "369cc4a0-7f38-450e-b802-7911c1ca672c",
   "metadata": {},
   "source": [
    "- `private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(\"user_prefs\")` - Ta linia definiuje rozszerzenie (extension property) dla klasy `Context`. Tworzy ono obiekt `DataStore` typu `Preferences` o nazwie `user_prefs`. Ten `DataStore` będzie używany do przechowywania i pobierania preferencji użytkownika.\n",
    "- `private val USERNAME_KEY = stringPreferencesKey(\"USERNAME\")` - Ta linia definiuje prywatną stałą, która reprezentuje klucz używany do przechowywania i pobierania nazwy użytkownika w `DataStore`. Jest to obiekt typu `Preferences.Key<String>`.\n",
    "- `suspend fun storeUsername(context: Context, username: String)` Ta funkcja służy do zapisywania nazwy użytkownika w `DataStore`.\n",
    "- `fun getUsernameFlow(context: Context): Flow<String>` - Ta funkcja zwraca strumień asynchroniczny typu `Flow<String>`, który będzie emitować nazwę użytkownika za każdym razem, gdy wartość ulegnie zmianie."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae8c2758-a8a7-4de6-9ddb-be719875de3a",
   "metadata": {},
   "source": [
    "Dodajmy repozytorium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27649679-73aa-4b29-943a-c4c65dcfc7a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class UserRepository(private val application: Application) {\n",
    "    fun getUsername() = SaveUsernameDataStore.getUsernameFlow(application)\n",
    "    suspend fun add(username: String) = SaveUsernameDataStore.storeUsername(application, username)\n",
    "    suspend fun clear() = SaveUsernameDataStore.storeUsername(application, \"\")\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a256661-56d9-486e-a8d8-b50062c38668",
   "metadata": {},
   "source": [
    "Podobnie jak przy wykorzystaniu `Room`, musimy przekazać kontekst aplikacji jako parametr konstruktora. Więc musimy przekazać go również przez `ViewModel`, który domyślnie nie przyjmuje żadnych parametrów, aby to zmienić musimy zaimplementować własną fabrykę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c9bdc2a-db6c-4540-9ef9-886375f15459",
   "metadata": {},
   "outputs": [],
   "source": [
    "class UserViewModelFactory(private val application: Application) :\n",
    "    ViewModelProvider.Factory {\n",
    "    override fun <T : ViewModel> create(modelClass: Class<T>): T {\n",
    "        return UserViewModel(application) as T\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0203833-918d-48cd-b3ba-48cc36da389c",
   "metadata": {},
   "source": [
    "Dodajmy `Viewmodel` - w kodzie nie ma żadnych nowych elementów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a5b89d5-cae7-4c31-b835-bee8cd536156",
   "metadata": {},
   "outputs": [],
   "source": [
    "class UserViewModel(application: Application) : ViewModel() {\n",
    "    private val repository: UserRepository\n",
    "    private val _username = MutableStateFlow(\"\")\n",
    "    val username: StateFlow<String>\n",
    "        get() = _username\n",
    "\n",
    "    init {\n",
    "        repository = UserRepository(application)\n",
    "        fetchUser()\n",
    "    }\n",
    "\n",
    "    private fun fetchUser() {\n",
    "        viewModelScope.launch {\n",
    "            repository.getUsername().collect { username ->\n",
    "                _username.value = username\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fun addUsername(username: String) {\n",
    "        viewModelScope.launch {\n",
    "            repository.add(username)\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fun clearUsername(){\n",
    "        viewModelScope.launch {\n",
    "            repository.clear()\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed29879-4f4e-476c-9e9f-9012c7a4695b",
   "metadata": {},
   "source": [
    "Następnie dodajmy funkcję renderującą ekran główny aplikacji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8498d8f4-3b4f-4fd6-8d00-685fb7189140",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Composable\n",
    "fun MainScreen(){\n",
    "\n",
    "    val viewModel: UserViewModel = viewModel(\n",
    "        LocalViewModelStoreOwner.current!!,\n",
    "        \"UserViewModel\",\n",
    "        UserViewModelFactory(LocalContext.current.applicationContext as Application)\n",
    "    )\n",
    "    val currentUsername by viewModel.username.collectAsStateWithLifecycle()\n",
    "\n",
    "    Column(modifier = Modifier.fillMaxSize()) {\n",
    "\n",
    "        Text(\n",
    "            text = \"Current saved username: $currentUsername\",\n",
    "            modifier = Modifier.padding(10.dp),\n",
    "            textAlign = TextAlign.Center,\n",
    "            fontSize = 24.sp\n",
    "        )\n",
    "\n",
    "        Button(\n",
    "            onClick = { viewModel.addUsername(DataProvider.username) },\n",
    "            modifier = Modifier.fillMaxWidth().padding(4.dp)\n",
    "        ) {\n",
    "            Text(text = \"ADD\")\n",
    "        }\n",
    "\n",
    "        Button(\n",
    "            onClick = { viewModel.clearUsername() },\n",
    "            modifier = Modifier.fillMaxWidth().padding(4.dp)\n",
    "        ) {\n",
    "            Text(text = \"CLEAR\")\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a55f35b-c6f6-4b79-927d-77388a59eb2e",
   "metadata": {},
   "source": [
    "W powyższym kodzie jedynym nowym elementem może być uzyskanie instancji `UserViewModel`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dcd3010-4833-47b1-b858-3a5593ad2690",
   "metadata": {},
   "outputs": [],
   "source": [
    "val viewModel: UserViewModel = viewModel(\n",
    "    LocalViewModelStoreOwner.current!!,\n",
    "    \"UserViewModel\",\n",
    "    UserViewModelFactory(LocalContext.current.applicationContext as Application)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04938a57-6fa4-4696-becb-901a8124d603",
   "metadata": {},
   "source": [
    "Chcemy skorzystać z zaimplementowanej wcześniej fabryki - funkcja `viewModel` przyjmuje kilka argumentów:\n",
    "\n",
    "- viewModelStoreOwner: ViewModelStoreOwner - Parametr określa właściciela `ViewModelStore`, do którego `ViewModel` będzie przywiązany. `ViewModelStore` to miejsce przechowywania `ViewModel` i ich stanu między rekompozycjami.\n",
    "- `key: String` - Jest unikalnym kluczem, który identyfikuje `ViewModel` wewnątrz `ViewModelStore`.\n",
    "- `factory: () -> T` - Tworzy instancję ViewModelu. Jest to sposób na odroczenie tworzenia `ViewModel` do momentu, gdy jest rzeczywiście potrzebny. Funkcja `factory` nie przyjmuje żadnych argumentów i zwraca instancję `ViewModel` (`T`). Gdy `viewModel()` jest wywoływane w środowisku `Compose`, funkcja `factory` zostanie wykonana tylko raz i instancja `ViewModel` będzie przechowywana i dostępna do ponownego użycia między rekompozycjami.\n",
    "\n",
    "Przekazane parametry:\n",
    "- `LocalViewModelStoreOwner.current!!` - `LocalViewModelStoreOwner` to zmienna lokalna, która dostarcza obiekt `ViewModelStoreOwner`. W tym przypadku wykorzystujemy `LocalViewModelStoreOwner.current!!`, co oznacza, że `ViewModel` jest przywiązany do bieżącego właściciela `ViewModelStoreOwner` w drzewie `Compose`.\n",
    "- `\"UserViewModel\"` - Jest to unikatowy klucz, który identyfikuje `ViewModel` w `ViewModelStore`.\n",
    "- `UserViewModelFactory(LocalContext.current.applicationContext as Application)` - Jest to instancja `UserViewModelFactory`, która dostarcza zależność (`Application`). W ten sposób `UserViewModel` może uzyskać dostęp do kontekstu aplikacji, co jest niezbędne do uzyskania instancji bazy danych."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "221656df-80b1-4923-87a9-69cf4a72796a",
   "metadata": {},
   "source": [
    "Wywołajmy funkcję w głównej aktywności."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9213b7e5-181b-4b88-b081-7e32ec4094a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MainActivity : ComponentActivity() {\n",
    "    override fun onCreate(savedInstanceState: Bundle?) {\n",
    "        super.onCreate(savedInstanceState)\n",
    "        setContent {\n",
    "            DataSoreBasicsComposeTheme {\n",
    "                // A surface container using the 'background' color from the theme\n",
    "                Surface(\n",
    "                    modifier = Modifier.fillMaxSize(),\n",
    "                    color = MaterialTheme.colorScheme.background\n",
    "                ) {\n",
    "                    MainScreen()\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5708945b-1d63-4fb3-8b44-b39c7c2b0015",
   "metadata": {},
   "source": [
    "Możemy przetestować aplikację."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "492fa4a0-c791-46a9-bcdc-e6feeaf78958",
   "metadata": {},
   "source": [
    "<img src=\"https://media0.giphy.com/media/v1.Y2lkPTc5MGI3NjExMHZ0Mmt6cjJwYjVrYzE0NWdpbHNqYXM5ZjVvNzc1bmhqZm1zY2F5NSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/kd4nprniMKNt9fBZIv/giphy.gif\" width=\"200\" />"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.0-RC"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}