2022-2023/Lab/Lab12/12.5.1 - Java - Dagger2 Value Inject.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5d5edb62-82c4-401a-8f56-88a03cf995e0",
   "metadata": {},
   "source": [
    "## 12.5 Wstrzykiwanie wartości (Value Injection)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac78055-afd7-49bf-a4fb-7f92813c2fde",
   "metadata": {},
   "source": [
    "Zajmijmy się teraz przekazaniem wartości przez konstruktor w czasie wykonania. Naszym przykładem dalej będzie `Computer`, tym razem będzie posiadał tylko jeden komponent - `GPU`. Klasa `GPU` będzie przyjmować jeden paramtetr przez konstruktor - liczbę rdzeni typu `Int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "683852d4-719b-42ce-9296-5ec7de66ce07",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Computer {\n",
    "\n",
    "    private GPU gpu;\n",
    "\n",
    "    @Inject\n",
    "    public Computer(GPU gpu) {\n",
    "        this.gpu = gpu;\n",
    "    }\n",
    "\n",
    "    public String getGpuCores(){\n",
    "        return String.valueOf(gpu.getGpuCores());\n",
    "    }\n",
    "}\n",
    "\n",
    "\n",
    "public class GPU {\n",
    "\n",
    "    private int gpuCores;\n",
    "\n",
    "    public GPU(int gpuCores) {\n",
    "        this.gpuCores = gpuCores;\n",
    "    }\n",
    "\n",
    "    public int getGpuCores() {\n",
    "        return gpuCores;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11b8dabc-84ca-4956-83ee-83585542436d",
   "metadata": {},
   "source": [
    "Teraz nie możemy wykorzystać adnotacji `@Inject` przy konstruktorze klasy `GPU` - liczba rdzeni będzie znana w czasie wykonania aplikacji (może być podana przez użytkownika). Musimy manualnie wywołać konstruktor i w jakiś sposób przekazać wartość `gpuCores`.\n",
    "\n",
    "Tym razem nasza klasa z adnotacją `@Module` będzie posiadała konstruktor w którym przekażemy wartość `gpuCores`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8cef6df-7576-443c-9528-791f92d61439",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Module\n",
    "public class GpuModule {\n",
    "    \n",
    "    private int gpuCores;\n",
    "\n",
    "    public GpuModule(int gpuCores) {\n",
    "        this.gpuCores = gpuCores;\n",
    "    }\n",
    "    \n",
    "    @Provides\n",
    "    GPU provideGpu(){\n",
    "        return new GPU(gpuCores);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3f5857-d0af-47aa-be6a-5a475aa2c880",
   "metadata": {},
   "source": [
    "Naszx `ComputerComponent` nie zawiera żadnych nowych elementów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1120ba4-94f3-440b-a38c-48cf5fb4954f",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Component(modules = GpuModule.class)\n",
    "public interface ComputerComponent {\n",
    "    void inject(MainActivity mainActivity);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "327d9305-34b8-4c4c-993f-d0d451f8bf6c",
   "metadata": {},
   "source": [
    "Zmiany natomiast pojawią się w automatycznie wygenerowanej klasie `DaggerComputerComponent`. Nie mamy dostępnej metody `create`, teraz musimy manualnie wywołać konstruktor klasy `GpuModule`. Do tego automatycznie generowana jest implementacja wzorca projektowego [budowniczy](https://refactoring.guru/pl/design-patterns/builder)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5393e151-2d33-47ac-957a-fa239f857f6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ComputerComponent component = DaggerComputerComponent.builder()\n",
    "    .gpuModule(new GpuModule(8))  // możemy przekazać liczbę rdzeni w czasie wykonania\n",
    "    .build();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b08d2518-0d01-42fe-8f7c-ea02a64d484b",
   "metadata": {},
   "source": [
    "Tak jak w poprzednich przykładach, trworzymy instancję obiektu o typie interfejsu `ComputerComponent`, następnie wywołujemy metodę `inject`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "170271ac-23f1-401d-8036-2bb7db10bf75",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class MainActivity extends AppCompatActivity {\n",
    "\n",
    "    @Inject\n",
    "    public Computer computer;\n",
    "\n",
    "    @Override\n",
    "    protected void onCreate(Bundle savedInstanceState) {\n",
    "        super.onCreate(savedInstanceState);\n",
    "        setContentView(R.layout.activity_main);\n",
    "\n",
    "        ComputerComponent component = DaggerComputerComponent.builder()\n",
    "                .gpuModule(new GpuModule(8))\n",
    "                .build();\n",
    "\n",
    "        component.inject(this);\n",
    "        TextView textView = findViewById(R.id.textview);\n",
    "        textView.setText(computer.getGpuCores());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c249c0d7-13c8-4fdb-81f3-f34c2589e29c",
   "metadata": {},
   "source": [
    "### Metoda dostarczająca"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4530d67-a15f-4a3d-9aeb-d83534394131",
   "metadata": {},
   "source": [
    "W klasie `GpuModule` przekazujemy jawnie wartość `gpuCores`, możemy jednak zaimplementować metodę dostarczającą dla tej zmiennej - dzięki temu możemy tą jedną wartość dostarczyć do wielu obiektów - jednym z zastosowań w androidzie jest przekazanie **applicationContext**.\n",
    "\n",
    "Powróćmy do klasy `GpuModule` i dodajmy metodę `provideGpuCores`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2fefefe-790e-4938-9602-47fc339204e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Provides\n",
    "int provideGpuCores(){\n",
    "    return gpuCores;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0298f9d-9aca-4739-bf15-3a246893c4e5",
   "metadata": {},
   "source": [
    "Teraz możemy wstrzyknąć za pomocą konstruktora `GPU`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d83122e-ec2a-4504-8067-4e332d343c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class GPU {\n",
    "    private int gpuCores;\n",
    "    \n",
    "    @Inject\n",
    "    public GPU(int gpuCores){\n",
    "        thi.gpuCores = gpuCores;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "819669ce-12cc-464b-a921-06ccf52c552b",
   "metadata": {},
   "source": [
    "Teraz z kolei, możemy zmodyfikować metodę `provideGpu` klasy `GpuModule` i przekazać `gpu` przez parametr."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fb394b3-6cf5-44ca-9b60-36cb9d2de4df",
   "metadata": {},
   "outputs": [],
   "source": [
    "@Provides\n",
    "GPU provideGpu(GPU gpu){\n",
    "    return gpu\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e98bccfd-7c27-4317-9f8a-518040e65923",
   "metadata": {},
   "source": [
    "Tutaj konieczne jest  pamiętanie i jednej istotnej rzeczy - `Dagger2` nie interesuje nazwa zmiennej, tylko jej **typ**. Co może być kłopotliwe - jeżeli konstruktor przyjmuje dwa parametry o typie `int`, `Dagger2` ich nie rozróżni. Jest to możliwe z kilkoma dodatkowymi adnotacjami. Elementy przedstawione do tej pory są wystarczające nac potrzeby tych zajęć, więc tutaj zakończymy omawianie biblioteki `Dagger2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1105e05-07f9-4b25-91e3-71ff1e0c0b85",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "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
}