2024-2025/Lab/Mod1/Lab3/3.1.2 RecyclerViewBasics - Java.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5eff8b5b-694f-4bff-b807-48acf2a25025",
   "metadata": {},
   "source": [
    "# RecyclerView"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c197722f-fb68-4d8a-aecb-8ea9a7a08b91",
   "metadata": {},
   "source": [
    "`RecyclerView` to widok (`View`) w Androidzie, który umożliwia wyświetlanie dużych i złożonych list w sposób efektywny. `RecyclerView` działa w oparciu o wzorzec projektowy `ViewHolder`, który umożliwia wykorzystanie istniejących elementów widoku do wyświetlania informacji, zamiast tworzenia nowych widoków dla każdego elementu na liście.\n",
    "\n",
    "W `RecyclerView` każdy element listy reprezentowany jest przez obiekt `ViewHolder`, który jest odpowiedzialny za wyświetlanie danych elementu. `RecyclerView` nie tworzy i nie usuwa elementów widoku za każdym razem, gdy element na liście jest przewijany w górę lub w dół. Zamiast tego, używa metody `onBindViewHolder()` do wykorzystania istniejących elementów widoku i zaktualizowania ich zawartości.\n",
    "\n",
    "Umożliwia tworzenie list z różnymi układami (layoutami), w tym listy pionowe i poziome, siatki (grid), kart itp. Oferuje także wiele wbudowanych funkcjonalności, takich jak animacje przewijania, przeciąganie elementów listy, przeciąganie do odświeżenia (swipe-to-refresh) oraz obsługa kliknięć na elementach listy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb8e586-4712-4b7f-8565-145bb55f53d2",
   "metadata": {},
   "source": [
    "Głównymi elementami `RecyclerView` są:\n",
    "\n",
    "- `RecyclerView.LayoutManager` - jest odpowiedzialny za zarządzanie układem elementów w `RecyclerView`, tj. decyduje, jak elementy listy są rozmieszczone na ekranie. Android oferuje kilka gotowych menadżerów układu, takich jak `LinearLayoutManager`, `GridLayoutManager`, `StaggeredGridLayoutManager`, które można wykorzystać w zależności od potrzeb.\n",
    "\n",
    "- `RecyclerView.Adapter` - jest odpowiedzialny za dostarczenie danych do `RecyclerView`. `Adapter` tworzy `ViewHolder'y`, przypisuje im odpowiednie dane i umieszcza je w `RecyclerView`. `Adapter` również obsługuje zdarzenia kliknięć na elementach listy.\n",
    "\n",
    "- `RecyclerView.ViewHolder` - reprezentuje pojedynczy element listy. `ViewHolder` zawiera widoki związane z elementem listy, które są wykorzystywane do wyświetlenia informacji na ekranie.\n",
    "\n",
    "Ponadto, istnieje wiele klas wewnętrznych, których wykorzystanie pozwala dodać różne właściwości do naszej listy:\n",
    "\n",
    "- `RecyclerView.ItemDecoration` - pozwala na dodanie dekoracji do elementów w `RecyclerView`, takich jak marginesy, linie oddzielające elementy, itp.\n",
    "\n",
    "- `RecyclerView.ItemAnimator` - umożliwia dodanie animacji podczas dodawania, usuwania i aktualizowania elementów w `RecyclerView`.\n",
    "\n",
    "- `RecyclerView.OnScrollListener` - pozwala na nasłuchiwanie zdarzeń przewijania w RecyclerView.\n",
    "\n",
    "- `RecyclerView.RecycledViewPool` - przechowuje \"pulę\" elementów `ViewHolder`, które zostały usunięte z `RecyclerView`, ale mogą zostać ponownie wykorzystane. Dzięki temu można uniknąć tworzenia nowych elementów `ViewHolder` za każdym razem, gdy element listy zostanie przewinięty na ekran."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5fd6aac-92b0-4b11-9cb9-82c9cafaaeae",
   "metadata": {},
   "source": [
    "W Androidzie dostępne są różne adaptery dla `RecyclerView`. Przykłady:\n",
    "\n",
    "- `RecyclerView.Adapter` - jest podstawowym adapterem dla `RecyclerView`. Jest on używany do wyświetlania listy pojedynczych elementów bez względu na to, jakie są ich typy.\n",
    "\n",
    "- `CursorAdapter` - służy do wyświetlania danych z kursora bazy danych w `RecyclerView`.\n",
    "\n",
    "- `FirebaseRecyclerAdapter` - adapter umożliwiający wyświetlanie danych z `Firebase Realtime Database` w `RecyclerView`.\n",
    "\n",
    "- `ArrayAdapter` - adapter służący do wyświetlania danych z tablicy w `RecyclerView`.\n",
    "\n",
    "- `PagedListAdapter` - specjalny adapter, który umożliwia paginację (ładować pojedyncze strony), co zwiększa wydajność i zmniejsza zużycie pamięci.\n",
    "\n",
    "- `ListAdapter` - adapter, który dziedziczy po `RecyclerView.Adapter` i oferuje dodatkowe funkcjonalności, takie jak automatyczne wykrywanie zmian w danych i wyświetlanie animacji podczas ich aktualizacji.\n",
    "\n",
    "- `GroupAdapter` - adapter umożliwiający łatwe tworzenie grupowanych list, w których elementy można grupować według określonych kryteriów.\n",
    "\n",
    "- `ConcatAdapter` - adapter, który umożliwia łączenie wielu adapterów w jednym `RecyclerView`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79f34967-fbda-4b9b-9ee8-837d71f9d5a7",
   "metadata": {},
   "source": [
    "Nasza aplikacja będzie wykorzystywać tylko podstawowe elementy `RecyclerView` do wyświetlenia listy słów. Rozpoczniemy od utworzenia layoutu pojedynczego elementu listy. Przechodzimy do **res -> layout** i z menu kontekstowego wybieramy **New -> Layout Resource File** i jako nazwę podaję `word_list_item`. Przejdźmy do nowoutworzonego pliku i dodajmy pole `TextView` w którym będziemy wyświetlać słowo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84464c02-cf1b-4341-8d08-92456f04cb43",
   "metadata": {},
   "outputs": [],
   "source": [
    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
    "<LinearLayout\n",
    "    xmlns:android=\"http://schemas.android.com/apk/res/android\"\n",
    "    android:layout_width=\"match_parent\"\n",
    "    android:orientation=\"horizontal\"\n",
    "    android:layout_height=\"wrap_content\">\n",
    "\n",
    "    <TextView\n",
    "        android:id=\"@+id/singleWord\"\n",
    "        android:layout_width=\"match_parent\"\n",
    "        android:layout_height=\"wrap_content\"\n",
    "        android:textSize=\"24sp\"/>\n",
    "\n",
    "</LinearLayout>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50bbf66a-6cf8-4b2c-b8da-2daab3f9f0e9",
   "metadata": {},
   "source": [
    "Przejdźmy do pliku `MainActivity` i utwórzmy naszą listę słów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "205e8fb3-9054-4655-9ad5-a781deb725b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class MainActivity extends AppCompatActivity {\n",
    "\n",
    "    private final ArrayList<String> wordList = new ArrayList<>();\n",
    "    \n",
    "    @Override\n",
    "    protected void onCreate(Bundle savedInstanceState) {\n",
    "        super.onCreate(savedInstanceState);\n",
    "        setContentView(R.layout.activity_main);\n",
    "        \n",
    "        for (int i = 0; i < 30; i++)\n",
    "            wordList.add(\"Word\" + i);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c4f3a5-2248-4642-815e-d04466e74708",
   "metadata": {},
   "source": [
    "Następnie utworzymy klasę `WordListAdapter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6284755c-77fb-4c08-be65-9c809f2b3879",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListAdapter extends RecyclerView.Adapter<WordListViewHolder> {\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb610a8b-e0d8-4baf-b5c8-7313f4383a04",
   "metadata": {},
   "source": [
    "Oraz klasę `WordListViewHolder`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f298b65-37dc-4f3a-a692-8187197bfac2",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListViewHolder extends RecyclerView.ViewHolder {\n",
    "    public WordListViewHolder(WordListItemBinding binding) {\n",
    "        super(binding.getRoot());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b622cc5-70f5-4d6e-900b-6fda8cb6a1f7",
   "metadata": {},
   "source": [
    "Utworzona klasa `WordListViewHolder` musi rozszerzać klasę `ViewHolder` klasy `RecyclerView`. \n",
    "\n",
    "Ponieważ klasa `WordListAdapter` rozszerza klasę `Adapter` więc musi implementować wszystkie jej metody."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de615303-5951-4534-9ca5-7d1fed4000a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListAdapter extends RecyclerView.Adapter<WordListViewHolder> {\n",
    "    @NonNull\n",
    "    @Override\n",
    "    public WordListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {\n",
    "        return null;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void onBindViewHolder(@NonNull WordListViewHolder holder, int position) {\n",
    "\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public int getItemCount() {\n",
    "        return 0;\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8a0921-d6d5-460b-ba18-b229e72e0a7d",
   "metadata": {},
   "source": [
    "Kod przedstawia szablon adaptera `WordListAdapter` dla `RecyclerView`, który dziedziczy po klasie `RecyclerView.Adapter` i wykorzystuje niestandardowy widok `WordListViewHolder`.\n",
    "\n",
    "- `onCreateViewHolder()` jest wywoływana, kiedy `RecyclerView` potrzebuje nowego widoku elementu listy, aby wyświetlić dane. Metoda ta zwraca nową instancję `WordListViewHolder`, który będzie wykorzystany przez RecyclerView.\n",
    "- `getItemCount()` zwraca liczbę elementów w liście, które będą wyświetlane przez `RecyclerView`.\n",
    "- `onBindViewHolder()` ustawia dane modelu (tutaj pozycję elementu listy) do `WordListViewHolder`, który będzie wykorzystany do wyświetlenia danych."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07aa585f-fe7b-4095-817a-83fdc76da415",
   "metadata": {},
   "source": [
    "Nasz layout elementu listy może być bardzo skomplikowany i zawierać wiele elementów - w tym prostym przykładzie mamy tylko jedno pole `TextView`. W przypadku gdy mamy wiele elementów i chcemy wykonać jakąś akcję - ale na całym elemencie listy a nie na jego części, musimy mieć możliwość zdefiniowania wspólnej metody dla całego elementu. Klasa `ViewHolder` udostępnia `itemView`, który oferuje taką funkcjonalność.\n",
    "\n",
    "Implementację rozpocznijmy od połączenia layoutu elementu z `ViewHolder`. w klasie `WordListViewHolder` dodaję funkcję `bind`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f47286e-5320-4309-a058-4fa1d9d9974e",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListViewHolder extends RecyclerView.ViewHolder {\n",
    "    private final WordListItemBinding binding;\n",
    "    public WordListViewHolder(WordListItemBinding binding) {\n",
    "        super(binding.getRoot());\n",
    "        this.binding = binding;\n",
    "    }\n",
    "    \n",
    "    public void bind(String item){\n",
    "        binding.singleWord.setText(item);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a1cc731-97e3-4d60-8d18-0d2919c76ab0",
   "metadata": {},
   "source": [
    "`WordListViewHolder` dziedziczy po klasie `RecyclerView.ViewHolder` i przyjmuje w konstruktorze obiekt klasy `WordListItemBinding`. Jest to klasa wygenerowana przez system wiążąca widoki z danymi w aplikacji.\n",
    "\n",
    "W metodzie `bind()` przypisywany jest element tekstowy do widoku `singleWord` przechowywanego w binding (plik `single_word_item.xml`). Ta metoda jest wywoływana w metodzie `onBindViewHolder()` klasy adaptera, aby wyświetlić elementy listy w `RecyclerView`.\n",
    "\n",
    "Przejdźmy do klasy `WordListAdapter`, dodajmy listę ze słowami do konstruktora."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0bb53f8-d1ae-4123-ac33-68dfbd642c0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "private ArrayList<String> wordList;\n",
    "\n",
    "public WordListAdapter(ArrayList<String> wordList){this.wordList = wordList;}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83fa92cb-0a59-4ac5-9037-978480b8addd",
   "metadata": {},
   "source": [
    "Rozpocznijmy implementację wszystkich metod. Rozpoczniemy od `getItemCount` - metoda zwraca ilość elementów. Tutaj będzie to rozmiar listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12deb1ed-df67-4d66-9551-7e15a27dc792",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Override\n",
    "public int getItemCount() {\n",
    "    return wordList.size();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb3f38c2-c3e7-480c-aeb0-9d647da305e6",
   "metadata": {},
   "source": [
    "Przejdźmy do metody `onCreateViewHolder`. Metoda zwraca `ViewHolder`, więc wywołujemy konstruktor klasy `WordListViewHolder`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1c58ca3-0a39-4da1-8e2b-78e032fd4880",
   "metadata": {},
   "outputs": [],
   "source": [
    "@NonNull\n",
    "@Override\n",
    "public WordListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {\n",
    "    return new WordListViewHolder(WordListItemBinding.inflate(\n",
    "            LayoutInflater.from(parent.getContext()), parent, false\n",
    "    ));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aca5776b-3d78-4343-b194-fe2b1ceaa36b",
   "metadata": {},
   "source": [
    "Metoda `onCreateViewHolder` jest wywoływana przez `RecyclerView` za każdym razem, gdy potrzebny jest nowy `ViewHolder`, czyli w momencie, gdy listę należy wyświetlić na ekranie lub gdy `RecyclerView` przewija listę i konieczne jest utworzenie nowych widoków dla elementów, które wchodzą do obszaru widoczności.\n",
    "\n",
    "W tym kodzie metoda ta zwraca nowy obiekt klasy `WordListViewHolder` za pomocą konstruktora, który przyjmuje obiekt klasy `WordListItemBinding`. Obiekt ten zostaje utworzony za pomocą metody `inflate()` z klasy `WordListItemBinding` i przekazany z wykorzystaniem klasy `LayoutInflater`. \n",
    "\n",
    "`LayoutInflater` umożliwia zamianę pliku układu na widok, który można wyświetlić w aplikacji, tworzy obiekty `View` na podstawie pliku `xml` ze zdefiniowanym layoutem. Instancję `LayoutInflater` otrzymujemy wywołując metodę `from` i przekazując do niej `Context`. `Context` zawiera informacje o całym środowisku naszej aplikacji i o jej aktualnym stanie. Dzięki tej klasie (implementowanej automatycznie) możemy uzyskać dostęp do zasobów naszej aplikacji, mamy możliwość interakcji pomiędzy różnymi komponentami aplikacji. Wywołujemy metodę `inflate` na obiekcie `LayoutInflater`, tworzy ona hierarchię obiektów na podstawie pliku `xml`. \n",
    "\n",
    "W konstruktorze `WordListItemBinding.inflate()` jako pierwszy argument przekazywany jest `LayoutInflater` pobrany z kontekstu rodzica (w tym przypadku rodzica `RecyclerView`). Jako drugi argument przekazywany jest `parent` (`ViewGroup`), czyli kontener, do którego zostanie umieszczony widok, a jako trzeci argument (`attachToRoot`) podawana jest wartość `false`, co oznacza, że nowy widok ma zostać dołączony do kontenera dopiero w momencie, gdy będzie gotowy.\n",
    "\n",
    "Ostatnią metodą jest `onBindViewHolder`, tutaj połączymy dane z odpowiednimi elementami layoutu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "368d9033-1ec9-4770-ace5-882d4c8ddf3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Override\n",
    "public void onBindViewHolder(@NonNull WordListViewHolder holder, int position) {\n",
    "    String currentItem = wordList.get(position);\n",
    "    holder.bind(currentItem);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c060c40-e1da-45f7-a6de-d9c6ec4fee0f",
   "metadata": {},
   "source": [
    "Ta metoda jest wywoływana przez `RecyclerView` w celu wyświetlenia danych w określonym elemencie wiersza, który jest powiązany z tym adapterem.\n",
    "\n",
    "`currentItem` jest pozycją elementu w danych, która jest pobierana z listy `wordList` na podstawie numeru `position`. Metoda `bind` w klasie `WordListViewHolder` jest odpowiedzialna za ustawienie odpowiedniego tekstu w widoku `TextView`, który jest częścią układu elementu listy.\n",
    "\n",
    "Metoda przypisuje zawartość elementu z danej pozycji `wordList` do widoku `TextView` w danym wierszu listy za pomocą `bind()`, co umożliwia wyświetlenie zawartości elementów w `Recycler View`.\n",
    "\n",
    "Pełny kod klasy `WordListAdapter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba1ab9b-6b15-4027-8caa-b037a1179cd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListAdapter extends RecyclerView.Adapter<WordListViewHolder> {\n",
    "\n",
    "    private ArrayList<String> wordList;\n",
    "\n",
    "    public WordListAdapter(ArrayList<String> wordList){\n",
    "        this.wordList = wordList;\n",
    "    }\n",
    "\n",
    "    @NonNull\n",
    "    @Override\n",
    "    public WordListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {\n",
    "        return new WordListViewHolder(WordListItemBinding.inflate(\n",
    "                LayoutInflater.from(parent.getContext()), parent, false\n",
    "        ));\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void onBindViewHolder(@NonNull WordListViewHolder holder, int position) {\n",
    "        String currentItem = wordList.get(position);\n",
    "        holder.bind(currentItem);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public int getItemCount() {\n",
    "        return wordList.size();\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aacb46af-33ea-4d06-92ee-4983794b1ab0",
   "metadata": {},
   "source": [
    "Dodajmy `RecyclerView` do `MainActivity`, w pierwszym kroku zmodyfikujemy layout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57474903-8128-4a23-adc9-a09ab4d0e9e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",
    "<LinearLayout 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=\"wrap_content\"\n",
    "    tools:context=\".MainActivity\">\n",
    "\n",
    "    <androidx.recyclerview.widget.RecyclerView\n",
    "        android:id=\"@+id/recyclerView\"\n",
    "        android:layout_width=\"match_parent\"\n",
    "        android:layout_height=\"wrap_content\" />\n",
    "\n",
    "</LinearLayout>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f4b9de7-b250-4afe-981c-85ab23f4dea9",
   "metadata": {},
   "source": [
    "Następnie w klasie `MainActivity` dodajemy `RecyclerView` i łączymy go z elementem layoutu."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79f54af6-bfe9-43e4-b681-7609e87dfaca",
   "metadata": {},
   "source": [
    "Następnie w klasie `MainActivity.kt` dodajemy `RecyclerView` i łączymy go z elementem layoutu. Następnie musimy utworzyć `WordListAdapter` i wskazać go jako adapter utworzonego `RecyclerView` przez wywołanie metody `setAdapter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a226df70-f3cd-461a-80d4-409214b299e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "binding.recyclerView.setAdapter(new WordListAdapter(wordList));\n",
    "binding.recyclerView.setLayoutManager(new LinearLayoutManager(this));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c8b23c8-fb9d-4af5-b731-f3091b1b860a",
   "metadata": {},
   "source": [
    "Ustawiamy adapter i menedżera układu dla `RecyclerView` na podstawie danych `wordList` i kontekstu aktywności `MainActivity`.\n",
    "\n",
    "`LinearLayoutManager(this@MainActivity)` tworzy nowy obiekt `LinearLayoutManager`, który zarządza położeniem elementów w `RecyclerView`. Argument `this@MainActivity` odnosi się do aktywności, w której znajduje się `RecyclerView`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbe59cee-24d0-4998-97fd-d17b154b1cfc",
   "metadata": {},
   "source": [
    "Na tym etapie możemy zbudować i przetestować naszą aplikację."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a8863ee-ad7e-4986-b0dd-d55558eb6110",
   "metadata": {},
   "source": [
    "## **Dodanie obsługi `onClick` dla każdego elementu listy**\n",
    "\n",
    "Chcemy dodać obsługę zdarzenia `onClick` elementu listy, nie będziemy implementować w metodzie `onBindViewHolder`, ponieważ chcemy uniknąć tworzenia wielu niepotrzebnych obiektów. Implementację metody przekażemy przez konstruktor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "500c9133-9814-4584-9c1f-d44e0f60d4af",
   "metadata": {},
   "source": [
    " Wpierw dodajmy interfejs OnItemClickListener do klasy InstituteViewHolder definiujący jedną metodę onItemClick przyjmującą int position jako argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ad021cb-bbf6-485b-bc37-d283640df59c",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface OnItemClickListener {\n",
    "    void onItemClick(int position);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "537b9833-04e7-4b1f-9791-9be6257e5884",
   "metadata": {},
   "source": [
    "Następnie do konstruktura `WordListViewHolder` dodamy obiekt o typie tego interfejsu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6ca62a9-54ba-4ecb-b34c-29a85af49805",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListViewHolder extends RecyclerView.ViewHolder {\n",
    "    private final WordListItemBinding binding;\n",
    "    public WordListViewHolder(WordListItemBinding binding, OnItemClickListener onItemClickListener) {\n",
    "        super(binding.getRoot());\n",
    "        this.binding = binding;\n",
    "        binding.getRoot().setOnClickListener(v ->\n",
    "                onItemClickListener.onItemClick(getAdapterPosition()));\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78044744-993f-4164-85f6-46795b3bdaff",
   "metadata": {},
   "source": [
    "W klasie `WordListAdapter` implementację metody przekażemy przez konstruktor - sama implementacja będzie znajdowała się w klasie `MainActivity`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a1bf7a6-1f21-48e7-a803-c0075766cf8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordListAdapter extends RecyclerView.Adapter<WordListViewHolder> {\n",
    "    private final ArrayList<String> wordList;\n",
    "\n",
    "    private final OnItemClickListener onItemClickListener;\n",
    "    public WordListAdapter(ArrayList<String> wordList, OnItemClickListener onItemClickListener) {\n",
    "        this.wordList = wordList;\n",
    "        this.onItemClickListener = onItemClickListener;\n",
    "    }\n",
    "\n",
    "    @NonNull\n",
    "    @Override\n",
    "    public WordListViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {\n",
    "        return new WordListViewHolder(\n",
    "                WordListItemBinding.inflate(\n",
    "                        LayoutInflater.from(parent.getContext()),\n",
    "                        parent,\n",
    "                        false),\n",
    "                onItemClickListener);\n",
    "    }\n",
    "    ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c271bfb6-61f1-4a30-b7dd-3da2859f3ba6",
   "metadata": {},
   "source": [
    "W klasie `MainActivity` dodajemy implementację metody `onClick`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6450d894-e1db-4208-8945-1a300b9c9beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "binding.recyclerView.setAdapter(new WordListAdapter(\n",
    "        wordList,\n",
    "        position -> Toast.makeText(this, \"Clicked \" + position, Toast.LENGTH_SHORT).show())\n",
    ");"
   ]
  }
 ],
 "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
}