Kung ikaw ay kasangkot sa pagbuo ng Android app, malamang na naranasan mo na ang pangangailangang mas maayos na isaayos ang iyong mga klase upang maiwasan ang tuluyang pagkagulo ng proyekto. Dito na... iniksyon ng dependency, isang disenyo na, bagama't maaaring mukhang itim na mahika sa simula, ay siyang paraan upang mabigyan ang bawat klase ng mga bagay na kailangan nito nang hindi kinakailangang gawin mismo ng klase ang mga ito.
Dumating ang Hilt upang iligtas tayo mula sa kasalimuotan ng Dagger, na nag-aalok ng isang pang-itaas na patong na nag-iistandardize ng paglalagay ng dependencySa pamamagitan ng pagsasama sa Jetpack, awtomatikong pinamamahalaan ng Hilt ang mga container at lifecycle, na nagbibigay-daan sa amin na tumuon sa business logic sa halip na maglipat-lipat ng mga bagay na parang lumilipat kami ng bahay.
Paunang Pagsasaayos ng Kapaligiran
Para masimulan ang paggamit ng Hilt, ang unang bagay ay ihanda ang lupain sa Gradle. Mahalagang idagdag ang hilt-android-gradle-plugin sa file sa antas ng proyekto. Pagkatapos, sa file ng module ng aplikasyon, dapat nating ilapat ang plugin at idagdag ang mga kaukulang dependency, tinitiyak na ang compiler (gamit ang kapt o KSP) ay wastong na-configure.
Isang detalyeng hindi natin maaaring balewalain ay, para maging maayos ang lahat, dapat i-configure ang proyekto para magamit Java 17 (o Java 8 sa mga mas lumang bersyon), dahil ito ay isang mahalagang kinakailangan para sa Hilt at Pagsulat ng Jetpack Magtrabaho nang may pagkakaisa. Kung mapapansin mong hindi nagko-compile ang programa kapag in-activate mo ang plugin, siguraduhing magkatugma ang mga bersyon ng Kotlin at KSP, dahil kahit ang maliit na pagkakaiba ay maaaring makasira sa buong proseso ng pag-compile.
Ang Puso ng Hilt: Ang Klase ng Aplikasyon
Anumang app na gustong makinabang mula sa library na ito ay dapat mayroong custom na Application class. Hindi sapat na basta likhain lamang ito; kailangan din natin itong markahan gamit ang anotasyon. @HiltAndroidAppAng linyang ito ang nagti-trigger sa pagbuo ng code ng Hilt at lumilikha ng root container ng aplikasyon.
Mahalaga ang pangunahing bahaging ito dahil nakaugnay ito sa pangkalahatang siklo ng buhay ng app at nagsisilbing pundasyon para sa lahat ng iba pang mga bahagi Maaari nilang ma-access ang mga dependency na tinukoy sa antas na ito. Siyempre, huwag kalimutang irehistro ang klaseng ito sa AndroidManifest.xml file gamit ang name attribute, kung hindi ay hindi mapapansin ang Hilt.
Paglalagay ng mga Dependency sa mga Android Component
Kapag handa na ang aplikasyon, maaari na nating simulan ang paglalagay ng mga dependency sa mga aktibidad, fragment, view, o serbisyo. Upang makamit ito, ginagamit natin ang anotasyon @AndroidEntryPointSinasabi nito sa Hilt na ang klaseng ito ay isang entry point at dapat itong bumuo ng isang partikular na component para dito.
Kapag gusto nating makakuha ng isang partikular na dependency sa loob ng isang aktibidad, ginagamit natin ang iniksyon sa larangan gamit ang anotasyong @Inject. Napakahalagang tandaan na Hindi maaaring maging pribado ang mga field na ito.Kung susubukan mong gamitin ang `private` modifier, ang compiler ay magpapakita ng error nang walang pag-aalinlangan. Sa kaso ng Jetpack Compose, ang paglalagay lamang ng anotasyon sa root Activity ay magbibigay-daan sa iyong ma-access ang ViewModels nang direkta sa loob ng mga composable function.
Mga Istratehiya para sa Pagtukoy ng mga Ugnayan
Kailangang malaman ng Hilt kung paano gawin ang mga bagay na hinihiling natin. Ang pinakadirektang paraan ay... iniksyon ng tagapagtayokung saan inilalagay natin ang @Inject bago ang class constructor. Sa ganitong paraan, sinusuri ng Hilt ang mga parameter at hinahanap kung paano ibibigay ang bawat isa sa mga dependency na iyon.
Pero siyempre, may mga pagkakataon kung saan wala tayong kumpletong kontrol sa klase, tulad ng kapag gumagamit tayo ng mga external library tulad ng Retrofit o OkHttpClient. Para dito, mayroon tayong... Mga Module ng HiltAng isang module ay isang klase na may anotasyon na @Module at dapat kasama ang @InstallIn upang ipahiwatig kung aling component ang dapat magkaroon ng dependency na iyon.
- Paggamit ng @Provides: Ginagamit ito kapag ang klase ay third-party o nangangailangan ng isang kumplikadong pattern ng konstruksyon. Dito, tinutukoy natin ang isang function na nagbabalik ng kinakailangang instance.
- Paggamit ng @Binds: Ito ang mainam na opsyon kapag gusto nating iugnay ang isang interface sa isang konkretong implementasyon. Ito ay binibigyang kahulugan bilang isang abstract function na nagsasabi sa Hilt: "kapag may humiling ng interface na ito, ibigay sa kanila ang implementasyong ito."
Pamamahala ng Saklaw at Siklo ng Buhay
Bilang default, lumilikha ang Hilt ng bagong instance sa bawat oras na humiling ng dependency. Gayunpaman, kung minsan kailangan nating manatiling pareho ang isang object sa buong buhay ng app o screen. Para diyan, ginagamit natin... saklaw ng mga bahagi.
Kung mamarkahan natin ang isang klase gamit ang @Singleton At kung i-install natin ito sa SingletonComponent, magkakaroon tayo ng isang pandaigdigang instance. Kung mas gusto natin na ang object ay umiiral lamang sa tagal ng aktibidad, gagamitin natin @ActivityScoped sa loob ng ActivityComponent. Mahalagang huwag labis na gamitin ang scope, dahil ang pagpapanatili ng mga object sa memory nang masyadong matagal ay maaaring makaapekto sa performance ng application.
Mga Espesyal na Kaso at Kwalipikasyon
Minsan kailangan nating mag-inject ng dalawang magkaibang implementasyon ng iisang interface. Para maiwasan ang labis na paggamit ng compiler, ginagamit natin mga kwalipikasyonAng isang qualifier ay karaniwang isang pasadyang anotasyon na ginagamit upang lagyan ng label ang isang partikular na binding, na nagbibigay-daan sa amin na makilala ang pagkakaiba, halimbawa, sa pagitan ng isang HTTP client para sa authentication at isa para sa mga pangkalahatang kahilingan.
Bukod pa rito, ginagawang mas madali ng Hilt ang ating buhay gamit ang mga paunang natukoy na kwalipikasyon tulad ng @Konteksto ng Aplikasyon at @ActivityContext, na nagbibigay-daan sa atin na makuha ang konteksto ng Android nang hindi kinakailangang i-configure ang mga manu-manong module para dito. Panghuli, para sa mga klase na hindi natively sinusuportahan ng Hilt (tulad ng ContentProviders), maaari nating gamitin ang anotasyon @EntryPoint, na lumilikha ng manu-manong tulay upang kumuha ng mga dependency mula sa Hilt graph. Ibahagi ang impormasyon at mas maraming user ang matututo tungkol sa paksa.