2022-2023/Lab/Lab9/9.1.1 - Java - ROOM podstawy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b40f0fcd-b79d-433d-a4ed-b39e0ba423fb",
   "metadata": {},
   "source": [
    " ## 9.1 ROOM - podstawy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93e4cfb4-aecc-4e11-8d15-9ca5391b06f6",
   "metadata": {},
   "source": [
    "Przyjrzyjmy się `ROOM` - jest to warstwa abstrakcji służąca jako punkt dostępu do do bazy `SQLite`, znacznie upraszcza pracę z wewnętrzną bazą na urzadzeniu. W tej aplikacji zaimplementujemy bazę przechowującą słowa - umożliwimy wyświetlanie wszystkich słów oraz dodanie nowego elementu. Wykorzystamy elementy architektury - `ViewModel`, `LiveData` oraz `ROOM`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e06eea-6e9b-4a04-a17d-e880c14e88d8",
   "metadata": {},
   "source": [
    "<img src=\"https://media3.giphy.com/media/MMcJ5i46Q0FIBspUEQ/giphy.gif\" width=\"200\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7df5cfc-cad5-4dd6-b807-14771230f3c5",
   "metadata": {},
   "source": [
    "Rozpocznijmy od dodania odpowiednich zależności"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f71dcab6-0845-4ea1-adc3-333eb8b6ffd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "// ROOM\n",
    "implementation \"androidx.room:room-runtime:2.4.3\"\n",
    "annotationProcessor \"androidx.room:room-compiler:2.4.3\"\n",
    "\n",
    "// ViewModel\n",
    "implementation 'androidx.lifecycle:lifecycle-viewmodel:2.5.1'\n",
    "// LiveData\n",
    "implementation \"androidx.lifecycle:lifecycle-livedata:2.5.1\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b907d94-8d6e-4b0e-a648-430ea17e27cd",
   "metadata": {},
   "source": [
    "Nasza aplikacja składała się tylko z jednej aktywności, na której dodamy `RecyclerView` - tym razem wykorzystamy `ListAdapter` (zamiast zwykłego adaptera) oraz `DiffUtil` do określenia różnic między elementami kolekcji."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24aca782-dd3c-4edd-a342-8bc6210db8a1",
   "metadata": {},
   "source": [
    "### **ROOM**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b179a5b-b391-4329-a583-ce9a655c3cb1",
   "metadata": {},
   "source": [
    "#### **Entity**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7893d6f0-ae25-4257-92e6-f5ec612be8a8",
   "metadata": {},
   "source": [
    "Tworzenie bazy rozpoczniemy od klasy `Word` jest to byt (`Entity`) reprezentujący tabelę w bazie `SQLite`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e77ff5-e4a8-4857-84ae-082eba24dd03",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Entity(tableName = \"word_table\")\n",
    "public class Word {"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d693ffe-8b14-4966-b592-119c55232155",
   "metadata": {},
   "source": [
    "`@Entity(tableName = \"word_table\")` - każda klasa oznaczona adnotacją `@Entity` reprezentuje tabelę `SQLite`. Możemy określić nazwę tabeli jaką chcemy nadać w samej bazie wykorzystując właściwość `tableName` - tylko w przypadku gdy chcemy aby nazwa tabeli była inna niż nazwa klasy.\n",
    "\n",
    "Nasza klasa będzie posiadała jedną właściwość (pole), będzie to słowo (`word`) typu `String`. Każda właściwość w klasie reprezentuje kolumnę w tabeli - więc w naszym przykładzie zostanie utworzona jedna tabela o nazwie `word_table` posiadająca jedną kolumnę o nazwie `word`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b3aafb9-01f0-4155-a10e-f1c0bdd3a618",
   "metadata": {},
   "outputs": [],
   "source": [
    "    @PrimaryKey\n",
    "    @NonNull\n",
    "    @ColumnInfo(name = \"word\")\n",
    "    private final String word;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6feb85c-1dad-4082-aa61-586c6c759fb6",
   "metadata": {},
   "source": [
    "- `@PrimaryKey` - każda `Entity` wymaga posiadania jednego klucza głównego (unikalnego identyfikatora), w tym przykładzie, dla uproszczenia, samo słowo będzie jednocześnie kluczem głównym.\n",
    "- `@NonNull` - oznacza że parametr, pole lub wartość zwracana metody nie może mieć wartości `null`\n",
    "- `@ColumnInfo(name = \"word\")` - pozwala nadać nazwę kolumnie, jeżeli jest ona inna niż nazwa pola - w tym przykładzie jest ona taka sama, więc tą adnotację możemy usunąć.\n",
    "\n",
    "Do naszej klasy dodajmy jeszcze getter oraz konstruktor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15978569-b5ef-40eb-9160-52403306633b",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public Word(@NonNull String word) {this.word = word;}\n",
    "\n",
    "    public String getWord(){return this.word;}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9744c859-8e73-40fd-825e-ae1d469e37c0",
   "metadata": {},
   "source": [
    "#### **DAO**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "add228d6-5dea-4414-adc0-2aaca9cecf0f",
   "metadata": {},
   "source": [
    "`DAO` (*Data Access Object*) weryfikuje kod `SQL` podczas kompilacji i powiązuje go z odpowiednią metodą - musi być interfejsem lub klasą abstrakcyjną."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f756728c-0880-468c-baf0-4a2b927f01c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Dao\n",
    "public interface WordDao {"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4065a85-e149-4e9d-9984-27e077e61cb1",
   "metadata": {},
   "source": [
    "Podobnie jak przy `@Entity` posługujemy się adnotacją `@Dao` do oznaczenia interfejsu jako części `ROOM`. Tutaj dodamy kilka metod pozwialających nam dodać element do bazy, usunąć wszystkie elementy oraz wyciągnąć z bazy listę posortowanych elementów. Rozpocznijmy od metody `insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56d3cbf8-3a98-4f7c-b1a7-b9cf3ce315c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "    @Insert(onConflict = OnConflictStrategy.IGNORE)\n",
    "    void insert(Word word);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a20addf-089a-4175-ab5f-2419f6e034e0",
   "metadata": {},
   "source": [
    "- `void insert(Word word);` deklaruje metodę wstawiającą jeden element\n",
    "- `@Insert` - specjalna adnotacja, która nie wymaga podawania wprost kodu `SQL` - istanieją jeszcze `@Delete` oraz `@Update` - mocno ułatwia to wykonywanie podstawowych operacji na bazie\n",
    "- `onConflictStrategy` - określa zachowanie w przypadku wystąpienia konfliktu podczas próby dodania elementu do bazy (czyli próby dodania elementu który już istnieje) - tutaj będziemy ignorować, czyli próba dodania słowa które już istnieje w bazie zostanie zignorowana\n",
    "\n",
    "Kolejną będzie metoda usuwająca wszystkie elementy z listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e48ba9b8-6b7d-4efc-af1a-ea58ef68e532",
   "metadata": {},
   "outputs": [],
   "source": [
    "    @Query(\"DELETE FROM word_table\")\n",
    "    void deleteAll();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "440bcbbe-37ba-4af8-b4d1-b43b790f7fba",
   "metadata": {},
   "source": [
    "Adnotacja `@Delete` służy do usuwania tylko jednego elementu, do usunięcia wszystkich musimy dodać odpowiednie zapytanie.\n",
    "- `@Query` - wymaga podania zapytania SQL jako parametru typu `String`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f3dd3f-8b88-43ed-b2d6-4892638a133f",
   "metadata": {},
   "source": [
    "Ostatnią metodą będzie `getAlphabetizedWords` zwracająca posortowaną listę wszystkich słów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc6f0f92-6932-45a4-a85f-759653628218",
   "metadata": {},
   "outputs": [],
   "source": [
    "    @Query(\"SELECT * FROM word_table ORDER BY word ASC\")\n",
    "    LiveData<List<Word>> getAlphabetizedWords();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917446eb-374c-4899-b618-69f1691768d9",
   "metadata": {},
   "source": [
    "Metoda zwraca listę wszystkich słów jako `LiveData`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3cc3953-0df1-4b62-af1c-86703d760651",
   "metadata": {},
   "source": [
    "#### **RoomDatabase**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e0dc19-6f08-407f-b0f6-09f76df08123",
   "metadata": {},
   "source": [
    "Jedną z ważniejszych cech bazy `ROOM` jest brak zezwolenia na wykonywanie zapytań na wątku głównym (nazywanym również wątkiem ui). Wszystkie zapytania zwracające dane z bazy są wykonywane asynchronicznie. Klasa reprezentująca samą bazę musi być **klasą abstrakcyjną** i musi rozszerzać klasę `RoomDatabase`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb1adb7c-90e8-4ada-a743-33fc8c769cea",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Database(entities = {Word.class}, version = 1, exportSchema = false)\n",
    "public abstract class WordRoomDatabase extends RoomDatabase {"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f438df96-c8fc-4fa5-a0a7-29c83dcc5732",
   "metadata": {},
   "source": [
    "Ponownie wykorzystujemy adnotację aby poinformować kompilator że ta klasa jest komponentem `ROOM`. Sama adnotacja `@Database` przyjmuje kilka parametrów\n",
    "- `entities` - określa byty (tabele) należące do bazy\n",
    "- `version` - określa wersję bazy\n",
    "- `exportSchema` - migracje baz danych tutaj pominiemy, więc ustawimy na `false`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1627851b-67e5-4b10-811c-ea85242942b9",
   "metadata": {},
   "source": [
    "Baza wystawia `DAO` przez abstrakcyjny getter dla każdego `@Dao`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67731f3a-5864-42fe-b23f-e11b60ef8025",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public abstract WordDao wordDao();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbd10fd1-a8b2-458f-9e88-ffb7f0f4b600",
   "metadata": {},
   "source": [
    "Samą bazę zaimplementujemy jako `Singleton` - będzie to implementacje [**double-checked**](https://www.baeldung.com/java-singleton-double-checked-locking) - aby zapobiec tworzeniu wielu instancji bazy. Innymi słowy chcemy zapobiec wielokrotnemu otwarciu bazy i niekontrolowanemu wykonywaniu operacji."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccd2351d-5310-4cc1-9769-a0e741b56569",
   "metadata": {},
   "source": [
    "W pierwszym kroku dodajmy zmienną `INSTANCE` w której będziemy przechowywać naszą jedyną instancję teggo obiektu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dde8d829-f6c8-4d0d-8d85-267dcbe0d20c",
   "metadata": {},
   "outputs": [],
   "source": [
    "    private static volatile WordRoomDatabase INSTANCE;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70f78ab8-24fd-4722-a64b-37f2a3116361",
   "metadata": {},
   "source": [
    "Tworzymy `ExecutorService`, który wykorzystamy do wykonywania operacji asynchronicznie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc0692b3-d5f8-47f7-9c16-5102e7daa4c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "    private static final int NUMBER_OF_THREADS = 4;\n",
    "    public static final ExecutorService databaseWriteExecutor =\n",
    "            Executors.newFixedThreadPool(NUMBER_OF_THREADS);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ebf17c1-672c-4b83-90c3-b6d944f7dcaf",
   "metadata": {},
   "source": [
    "Potrzebujemy jeszcze metodę `getDatabase`, która zainicjuje nam bazę jeżeli ta jeszcze nie istnieje, lub zwróci nam `INSTANCE` jeżeli została utworzona wcześniej. Wpierw wykonajmy podwójne sprawdzenie oraz dodajmy blok `synchronized`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5466f84-a9c4-46f8-863f-3589190b9bf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public static WordRoomDatabase getDatabase(final Context context) {\n",
    "        if (INSTANCE == null) {\n",
    "            synchronized (WordRoomDatabase.class) {\n",
    "                if (INSTANCE == null) {\n",
    "                    \n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return INSTANCE;\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d40cb2f3-149a-415a-a1b2-591be59811d1",
   "metadata": {},
   "source": [
    "Wewnątrz bloku synchronized tworzymy bazę jeżeli `INSTANCE == null`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2193aed2-97e8-4517-a471-842e2a2c90b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public static WordRoomDatabase getDatabase(final Context context) {\n",
    "        if (INSTANCE == null) {\n",
    "            synchronized (WordRoomDatabase.class) {\n",
    "                if (INSTANCE == null) {\n",
    "                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),\n",
    "                                    WordRoomDatabase.class, \"word_database_javav2\")\n",
    "                            .build();\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        return INSTANCE;\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2317d0f2-fb72-4b3c-8638-428b8e60c701",
   "metadata": {},
   "source": [
    "W tym celu wykorzystujemy `Room.databaseBuilder` który przyjmuje kontekst. Zwróćmy uwagę na zastosowanie kontekstu aplikacji, a nie np. aktywności - kontekst aplikacji jest najszerszym kontekstem i najczęściej to na nim tworzymy bazę i wszystkie powiązane z nią elementy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7afae63-05c0-4ecb-a0b0-c8711aaff877",
   "metadata": {},
   "source": [
    "### **ViewModel**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da602dd8-a9ed-4631-956d-186061e63e86",
   "metadata": {},
   "source": [
    "Utwórzmy `ViewModel` - tym razem rozszerzymy `AndroidViewModel`, a nie jak poprzednio `ViewModel` - różnica jest w parametrze. `AndroidViewModel` może przekazać parametr. Dodajmy też dwa pola reprezentujące bazę danych oraz `LiveData` naszej listy słów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fad8122c-c217-4df5-9c78-2533bcc4cb51",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordViewModel extends AndroidViewModel {\n",
    "\n",
    "    private final WordRoomDatabase db;\n",
    "\n",
    "    private final LiveData<List<Word>> allWords;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1823dc57-4279-4442-bc7d-95dbaac4b0db",
   "metadata": {},
   "source": [
    "Ponieważ `RoomDatabase` wymaga podania kontekstu (zazwyczaj jest nim `Application`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5979e7f-2491-471e-a552-424ecdeaa7e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public WordViewModel (Application application) {\n",
    "        super(application);\n",
    "        db = WordRoomDatabase.getDatabase(application);\n",
    "        allWords = db.wordDao().getAlphabetizedWords();\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24fb102a-7a2f-40aa-b882-dc35c52576fd",
   "metadata": {},
   "source": [
    "Dodajmy również getter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc54058d-2eea-4039-8cf9-e80cb83e420c",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public LiveData<List<Word>> getAllWords() { return allWords; }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bad1dc69-f55d-48dd-bc8b-dfa14c05dcad",
   "metadata": {},
   "source": [
    "Ostatnią metodą klasy będzie `insert` umożliwiająca dodanie elementu do bazy - wykorzystamy `ExecutorService` zdefiniowany w klasie `WordRoomDatabase`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ed0a124-ffec-4060-a136-aa59c4a34095",
   "metadata": {},
   "outputs": [],
   "source": [
    "    public void insert(Word word) {\n",
    "        WordRoomDatabase.databaseWriteExecutor.execute(() -> \n",
    "            db.wordDao().insert(word));\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68645a6b-9a4b-44ea-9b09-b9ec23b49cc9",
   "metadata": {},
   "source": [
    "### **RecyclerView + ListAdapter + DiffUtil**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af629fb0-01ab-4352-b2bb-56674467e05f",
   "metadata": {},
   "source": [
    "Przejdźmy do wyświetlenia danych i umożliwienia dodania nowego słowa. Wpierw zdefiniujmy layouty. Layout głównej aktywności zawierający `RecyclerView`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e029cbff-6ddd-41cb-b264-74e2b4857742",
   "metadata": {},
   "outputs": [],
   "source": [
    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
    "<androidx.constraintlayout.widget.ConstraintLayout\n",
    "    xmlns:android=\"http://schemas.android.com/apk/res/android\"\n",
    "    xmlns:app=\"http://schemas.android.com/apk/res-auto\"\n",
    "    xmlns:tools=\"http://schemas.android.com/tools\"\n",
    "    android:layout_width=\"match_parent\"\n",
    "    android:layout_height=\"match_parent\"\n",
    "    tools:context=\".view.MainActivity\">\n",
    "\n",
    "    <androidx.recyclerview.widget.RecyclerView\n",
    "        android:id=\"@+id/recyclerview\"\n",
    "        android:layout_width=\"0dp\"\n",
    "        android:layout_height=\"0dp\"\n",
    "        tools:listitem=\"@layout/recyclerview_item\"\n",
    "        android:padding=\"12dp\"\n",
    "        app:layout_constraintBottom_toBottomOf=\"parent\"\n",
    "        app:layout_constraintLeft_toLeftOf=\"parent\"\n",
    "        app:layout_constraintRight_toRightOf=\"parent\"\n",
    "        app:layout_constraintTop_toTopOf=\"parent\" />\n",
    "\n",
    "    <com.google.android.material.floatingactionbutton.FloatingActionButton\n",
    "        android:id=\"@+id/fab\"\n",
    "        app:layout_constraintBottom_toBottomOf=\"parent\"\n",
    "        app:layout_constraintEnd_toEndOf=\"parent\"\n",
    "        android:layout_width=\"wrap_content\"\n",
    "        android:layout_height=\"wrap_content\"\n",
    "        android:layout_margin=\"16dp\"\n",
    "        android:contentDescription=\"add word\"\n",
    "        android:src=\"@drawable/ic_add\"/>\n",
    "\n",
    "</androidx.constraintlayout.widget.ConstraintLayout>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "420de322-378e-40b3-8b8b-9f3b8c3b8b8f",
   "metadata": {},
   "source": [
    "Dodajmy również layout dla pojedynczego elementu listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "663faafc-8588-45ac-876b-499ae8d1baa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
    "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n",
    "    android:orientation=\"vertical\"\n",
    "    android:layout_width=\"match_parent\"\n",
    "    android:layout_height=\"wrap_content\">\n",
    "\n",
    "    <TextView\n",
    "        android:id=\"@+id/textView\"\n",
    "        android:layout_width=\"match_parent\"\n",
    "        android:layout_height=\"wrap_content\" />\n",
    "</LinearLayout>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81533cea-bd69-4a43-86a8-47b9f6d725d3",
   "metadata": {},
   "source": [
    "Rozpocznijmy od utworzenia klasy `ViewHolder`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56348738-e6c4-4f0c-9490-ec0affa80c3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class WordViewHolder extends RecyclerView.ViewHolder {\n",
    "    private final TextView wordItemView;\n",
    "\n",
    "    private WordViewHolder(View itemView) {\n",
    "        super(itemView);\n",
    "        wordItemView = itemView.findViewById(R.id.textView);\n",
    "    }\n",
    "\n",
    "    public void bind(String text) {\n",
    "        wordItemView.setText(text);\n",
    "    }\n",
    "\n",
    "    static WordViewHolder create(ViewGroup parent) {\n",
    "        return new WordViewHolder(LayoutInflater.from(parent.getContext())\n",
    "                .inflate(R.layout.recyclerview_item, parent, false));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa36c087-0e46-44ab-bff5-56e3c9e525f9",
   "metadata": {},
   "source": [
    "Wykorzystamy tutaj metodę statyczną `create` z prywatnym konstruktorem. Następnie Dodajmy klasę `WordComparator` rozszerzjącą klasę `DiffUtil.ItemCallback`, służy ona dwóm celom\n",
    "- indeksowanie list\n",
    "- rozróżnianie elementów\n",
    "\n",
    "Mamy do zaimplementowania dwie metody\n",
    "- `areItemsTheSame` - wskazująca czy dwa elementy są tym samym (np. porównanie referencyjne)\n",
    "- `areContentsTheSame` - wskazująca czy dwa elementy są takie same (np. porównanie strukturalne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "261c6116-955a-4531-98f4-9f0103656d5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class WordsComparator extends DiffUtil.ItemCallback<Word> {\n",
    "\n",
    "    @Override\n",
    "    public boolean areItemsTheSame(@NonNull Word oldItem, @NonNull Word newItem) {\n",
    "        return oldItem == newItem;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public boolean areContentsTheSame(@NonNull Word oldItem, @NonNull Word newItem) {\n",
    "        return oldItem.getWord().equals(newItem.getWord());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46a23e82-cf08-4626-be7e-d5568ef58739",
   "metadata": {},
   "source": [
    "Pozostaje implementacja `WordListAdapter` rozszerzającej `ListAdapter` - jest to klasa dostarczająca taką samą funkcjonalność jak `RecyclerView.Adapter`, dodatkowo umożliwia obliczenie różnic między listami (na wątku roboczym)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "924fe106-fb6f-43ed-a812-9404de999f2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListAdapter extends ListAdapter<Word, WordViewHolder> {\n",
    "\n",
    "    public WordListAdapter(@NonNull DiffUtil.ItemCallback<Word> diffCallback) {\n",
    "        super(diffCallback);\n",
    "    }\n",
    "\n",
    "    @NonNull\n",
    "    @Override\n",
    "    public WordViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {\n",
    "        return WordViewHolder.create(parent);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void onBindViewHolder(WordViewHolder holder, int position) {\n",
    "        Word current = getItem(position);\n",
    "        holder.bind(current.getWord());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9484a008-fc66-4758-a2b7-cd66f791f3a7",
   "metadata": {},
   "source": [
    "### **Aktywność**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27d0c540-5dde-415d-9be3-b9d5f8173aec",
   "metadata": {},
   "source": [
    "Do głównej aktywności dodajmy dwie zmienne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49a15f34-bd02-4cca-bbd7-d74306c00fab",
   "metadata": {},
   "outputs": [],
   "source": [
    "    private WordViewModel wordViewModel;\n",
    "    private int num = 0; // licznik słów"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c688d36-e48f-4b7f-a4f9-811bb14d500e",
   "metadata": {},
   "source": [
    "W metodzie `onCreate` tworzymy `wordViewModel` przez wykorzystanie `ViewModelProvider`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b61ce372-a003-47eb-9a18-7c8b5f517ecf",
   "metadata": {},
   "outputs": [],
   "source": [
    "wordViewModel = new ViewModelProvider(this).get(WordViewModel.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c019dc-a238-4e4f-9621-863e746f9224",
   "metadata": {},
   "source": [
    "Tutaj zaznaczmy że nie jest to najlepsza metoda, ale w tym prostym przykładzie będzie wystarczająca"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ab80a68-6d3c-43b6-bfb4-864e2c575da2",
   "metadata": {},
   "source": [
    "Dodajmy `Recyclerview`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba6eb854-28fe-4f9b-811b-41255e5bbf34",
   "metadata": {},
   "outputs": [],
   "source": [
    "RecyclerView recyclerView = findViewById(R.id.recyclerview);\n",
    "final WordListAdapter adapter = new WordListAdapter(new WordsComparator());\n",
    "recyclerView.setAdapter(adapter);\n",
    "recyclerView.setLayoutManager(new LinearLayoutManager(this));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff1d1b8-9722-4ad9-858c-e2648a364345",
   "metadata": {},
   "source": [
    "Podłączmy obserwator do listy słów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0627cf7-bd07-4f23-a4ac-865876db0720",
   "metadata": {},
   "outputs": [],
   "source": [
    "wordViewModel.getAllWords().observe(this, adapter::submitList);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39893de3-4f3e-4e15-85f0-fa4af2f6da53",
   "metadata": {},
   "source": [
    "Gdy pojawia się nowa wersja listy wywołujemy metodę `submitList` klasy `ListAdapter` - lista zostaje automatycznie odświeżona przy każdej zmianie."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11124dce-1648-400f-b3d1-6f2eac438c45",
   "metadata": {},
   "source": [
    "Na koniec dodajmy możliwość dodania nowego słowa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ec68e34-0e90-4602-9d10-6f3a2223a292",
   "metadata": {},
   "outputs": [],
   "source": [
    "FloatingActionButton fab = findViewById(R.id.fab);\n",
    "fab.setOnClickListener(v -> {\n",
    "                wordViewModel.insert(new Word(\"word \" + num));\n",
    "                num++;\n",
    "            });"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0e88e89-47bc-48d9-8618-845be679d898",
   "metadata": {},
   "source": [
    "Możemy przetestować aplikację"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9868a2f2-3ed6-4329-bb30-f01ae184b77b",
   "metadata": {},
   "source": [
    "<img src=\"https://media3.giphy.com/media/MMcJ5i46Q0FIBspUEQ/giphy.gif\" width=\"150\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a0e169-c3d0-45b0-a592-6dc0e758fae4",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17+35-2724"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}