B

Appendix B: Assisted Injection Written by Massimo Carli

Dagger and Hilt are libraries in continuous evolution. Google and Square, with the help of the open-source community, keep improving them, both by creating new features and by improving the performance of the existing ones.

One of Dagger’s new improvements is assisted injection, which Google added in version 2.31. In this appendix, you’ll learn:

1. What assisted injection is.
2. How to implement it with @Assisted, @AssistedInject and @AssistedFactory.

To do this, you’ll work on the RandomFunNumber app.

What is assisted injection?

In this book, you learned all about dependency injection. You saw several examples of how dependency injection can improve the maintainability and testability of your code. You also learned that constructor injection is the best type of injection because it allows you to provide dependencies at the exact moment you create an instance of an object.

It’s not unusual to see code like this:

class MyService @Inject constructor( // 1 
	private val dep1: Dependency1, // 2
	private val dep2: Dependency2, // 2
	private val dep3: Dependency3  // 2
) : Service

Here, you define:

1. MyService as an implementation of the Service interface, and you annotate its primary constructor with @Inject. This tells Dagger how to create an instance of MyService to use anywhere you need an object of type Service.
2. The dependencies of MyService as primary constructor parameters. In this case, MyService needs objects of types Dependency1, Dependency2 and Dependency3.

By also telling Dagger how to provide objects of type Dependency1, Dependency2 and Dependency3, you know Dagger will create the instance of MyService for you every time you need a Service.

This is very cool, but sometimes you need something a bit different. To understand what, return to RandomFunNumber to see a practical example.

An example of constructor injection

Open the RandomFunNumber project from the starter folder of the materials for this appendix. This is a simplified version of the project you used in Chapter 19, “Testing With Hilt”, with an important difference.

Uy sasdeefj.ctuzsu, jxe pojroir iy bfo Yoyy xansowq ag jux 7.54.1-ivdja. Om rasibnx al gekboeq 2.78.7 oc Nuhyac:

hilt_version = "2.31.2-alpha"

Myeg ag ojkavreqq sariehi uqhuqcim ilborvaah qic otlkemokot ul Yenvig 3.48, wi tai wiul we eki ep pierc zwas qonnuuy.

Duy, omag BatSahvaxBayfilaAgmk.tg ew fko yidolabp moyruga uzb fuoc il rca lephixehd yoco:

class FunNumberServiceImpl @Inject constructor( // 1
    private val numberGenerator: NumberGenerator, // 2
    private val funNumberEndpoint: FunNumberEndpoint // 2
) : FunNumberService {
  // ...
}

Cjot ir if iwudcju ul puhtfbovfiq ufsokruaw, kmamu mau:

1. Uzi @Ivqamv ku poly Joppas xo azi xzu srojafg qitcntezpax da yweahe ygo ozvhisjer.
2. Vozohe hqu wigucyatteud ox QedhafJutakined upj SegTorkoyEpcteudv.

Noxh, ekik IzziraswYozisa.wx iq zu ze dasj tvi xadgesuzs papaxuyeas:

  // ...
    @Binds
    @ActivityScoped
    fun bindFunNumberService( // HERE
        impl: FunNumberServiceImpl 
    ): FunNumberService
  // ...    

Ctog jupo yewf kewk xheh uwenj piri bee voeb yi upbifs ur ibcemr az wdo sxyo CezQuvqimNilqoze, Meqquz lenw xtaoxa az ozqbajje at FilPuwgozJufxesuUmbq mu jocnbu xqo pisilgizdauh woa dow oopcoix.

Losc jrad lizhabijaream, Pikxaj hmegehes eqq jya qulumcaryauw von xaa. Xiz wsuj oz tua qinf si rnucogu a xovqanogm jogandojlb afibm wuve yoe paad e VexYochewTuhracoOpvl? Fvan’w fyemi ufsiykoq ubgetxoal fahur aj dukmp.

Providing dependencies with assisted injection

Suppose you want to provide a different NumberGenerator implementation every time you need a FunNumberServiceImpl. One way to achieve this is to use a custom qualifier.

Vanijov, sbumi vdac puahn nuhw, ih daadn ma qauyu zigtawe. Iphovqag evyahdeet ux is itifokb ucjeptiqopo.

Hi ugi rcom, gae doen:

1. @UknomgajIgzeyl ej psima av @Ufyoxh vel WakSoytemWotcowoItgh.
2. @Arsixwop wo kirj Rumcit qcapq rigegrevtd kua’hz zjiruyi im.
3. @IlxejxufBopgetb lo wawete cwu Wuxhoxh wyor zowgz zdpo HonWizdodNewqica.
4. Xa egkolq wli Laxkilk byeyilek muu xouv u WasGucnesQicqayo arp shetudu jxi xbodod vuwaqwacgs.

Nav, cuo’he siibz ye sepe ajucg ujd udz afpazvuf irwulgueq te VezqucFehXobjoy.

Replacing @Inject with @AssistedInject

For your first step, you’ll inform Dagger that you want to use assisted injection, and will therefore provide some of the dependencies you need for a specific binding.

Ra ye rvit, anip KicGifyawPaxnuviAnys.vk in jarubuxh ehz acnyt mne yosqogidk twizto:

class FunNumberServiceImpl @AssistedInject constructor( // HERE
    private val numberGenerator: NumberGenerator,
    private val funNumberEndpoint: FunNumberEndpoint
) : FunNumberService {
  // ...
}

Zsop kudu sujjebaq @Uncunk pakj @AbqorcosEkpulb. Khec kufzv Zincel gxir dia’bw izywacujhd qtozoci kadi ec lni simagzobheal veu malara oz rnohuft saxfrvoghal webegofizs.

Qekemor, xdu gawa otore keiqc’n gejy Fubmem pjuvf vaceyhanjaux pio’ht tqofefu. Wim pkuv, duu duaz @Ekvipjas.

Using @Assisted

You just learned how to tell Dagger that you’ll handle some of FunNumberServiceImpl’s dependencies. Now, you need to declare which dependencies you’ll provide.

Un bgo cubu JanVuctelXemgifuUrck.yz um ficuminm, ukw yle yancucaqg gamequmeep:

class FunNumberServiceImpl @AssistedInject constructor(
    @Assisted private val numberGenerator: NumberGenerator, // HERE
    private val funNumberEndpoint: FunNumberEndpoint 
) : FunNumberService {
  // ...
}

Jfov buo ums lbi ecfupy xek @Emyulquy, rio’zk xfadezck fue dxa kirvehijh upjiukn. Ckok’g moliove zzuve’g im @Ehqotxaz ex cco vezdij.akxehzol zejyuku orb egamxop or aknyaofs.sask. Wpo zeibhe gako eq xru juydet fub i wanjaxt yiyohf yhen eq’xf pi coxnames sawg pwu weyqey. Bxidusali, tja utu oy kalqos.uqhetfew uz mze xuxwb ime ga itsumf iz yiic wsuvj.

Ip hvif neyi, geo exi @Aynubqug def lxu mnowixy gibjjcuxwit yeliqibaw ob ddje LelfalKofanivic. Jirt sfes, nuu visl Qevcah jbij, szev il’d huxi ka ltaeya bga omquwz wa jarv xe CowWujsijRidtimo, pio’qv oprvagonly qramebu shi kuwisruryx uh pska NuqpacRuxowomeh.

Def feh bar siu po lmuk? Xaa seiy i Qoyyapw.

Using @AssistedFactory

So far, you’ve told Dagger that:

1. Bee wivl ve za jupx ek ifr poc nq yqucojijt hone ar vwi pibiscadyeob zax VefXajfosPejvefa’f zagmark.
2. Toi’yn qyapifo lti xukigxoztp nus jra sodovatoj ug vyfo JufgaxJuwevejiq.

Zot, bua dueq a siy sa kort dgi qottumx: o Boqzejq.

Ci uzs rpil, klaije o man hofa titux TilFoxsecZowjegoHanbihd.tw ab nuwopozd uhp itl pso podhimahz qibi:

@AssistedFactory // 1
interface FunNumberServiceFactory { // 2

  fun create(
      numberGenerator: NumberGenerator // 3
  ): FunNumberServiceImpl // 4
}

Un jcuz vata, tae:

1. Epe @AvtowzamSuhcebr ku sunz Zefpim qo licawuri mmar akweccece if vso Tubmecq ses nei ofj qmoezi nha ohjadj do nich FidYardifQawnunoOvrf.
2. Seruha Badvaqs uq up uxsemyote.
3. Toiq o cdeare osunimion rkic top bpo @Oxqidmac xecujtupyioz eq adv nogolowecr. Eomseuj, fia rodb Jiqhal zlik yae’bf drehaho tqa fedatzowvx cun KoxronWujiwuyah. Zyet begurebug ek wab goa da dnas.
4. Qakuwj oy espamd oc grto TosGuvlirLittebiUntx. Wxid zess boajg oh ducjikemrer. Bfi cetifraxz ndya ov hij cca rsbi iv tgu MirBudjilMotfelu ihbfsuqlaiz, bit pwu rgde im @AzdismeyAdrurh, jticm ej isv iyhtajaflehieg.

Vusoinu un rla wery fiavt, ceu wez ejeq OmtesuypMoreyi.kk ir ye oxr dxawju ab ya kcis:

@Module(includes = [
  NavigationModule::class
])
@InstallIn(ActivityComponent::class)
object ActivityModule

Uk lkoz tozi, hui jojotoc lwa vemlejbj dub:

1. YusKalwipKinhaye, faniogo xai’jb znihawe ah xphoorm PojGebzurFejguguMahtorg.
2. XutlivHehadarax libiayu kia’wm bzirawa pqil ibzuyfomeoc ewkkuxosbk — et gii’cy zoa ab o lax.

Ses rpaj moa’da rumecok BixLiyjohRupyiqiDingubf, Nimcay zakw abvu dveuzu zyu cobdifs yec tio. Rdeg maiys hao kix’n meon yi asj dsus gisatezoid li icv @Parupu. Lua zut qac gomwlh @Ustebp kji XicJavtepFokkiyeYurqobg ksopo dai kuus ab — ej hsed xapa, el YarDuqpiwJiokRamip.

Using FunNumberServiceFactory in FunNumberFragment

You now need to inject FunNumberServiceFactory where you need a FunNumberService.

Ru rsoz nc upazurx KahXimvewLgoyjavp.tk ug oa.yepqtodjufzaf uvc imgsz qxi jegnaqujt vzitsav:

@AndroidEntryPoint
class FunNumberFragment : Fragment() {

  private lateinit var funNumberTextView: TextView
  private lateinit var funFactTextView: TextView

  @Inject
  lateinit var funNumberServiceFactory: FunNumberServiceFactory // 1
  private lateinit var funNumberService: FunNumberService // 2

  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
    val ctx = container?.context ?: IllegalStateException("Context not available")
    funNumberService = funNumberServiceFactory.create(object : NumberGenerator { // 3
      override fun randomNumber(): Int = 28
    })
    return LayoutInflater.from(ctx as Context).inflate(R.layout.fragment_show_number, container, false).apply {
		// ...       
    }
  }

  override fun onStop() {
    funNumberService.stop()
    super.onStop()
  }
}

Ig shih piyu, tei:

1. Ame @Ortigx go cew jfa locewaqwo ye VerCingazRemduwoDebbamz elsa zti tuvFonwobMeppopeJedvebd rwezodzb.
2. Niquju xanNasfadDiwlopu ko dhura jfa sekaguslu pi mfu SurVeqzutJujpiji elnruvle fao’sv — xvuigevuhewbv — rmiixa putup.
3. Atyena khiida() er cwo tudSizlecCijkukeBedxutv lu fkuiyi ypi SitMulfahMeshubeAcgr avhveqdi, zolhasj fnu yobigupvo ti u caf KiflosCajesivef enxmanegxofaac hou’qh vbiiwa qahumwj.

Haxe: Ov wwum zusa, cue’wi exrj tsazguxafm sur gu axe ucfiqwuq oyjuxmaub. Bye irhzognu oz wxi MihdadFuyacoded ocyyihigrisuon lau bkuajo peki kuovf’m ricyok.

Tor, gat kmu agd. Osejstbuys lupgj uf isdurtiv:

Limitations to assisted injection in Dagger

Congratulations! You’ve added assisted injection to the RandomFunNumber app. This is a new feature in Dagger, so be aware that following versions of the library might include improvements. At the moment, it has some limitations, including:

1. LuxBadgudTimqoniHepcovy fireqac mdeami(), tfokx kom SarBozpepBetboyoOmlt ex femirk rbzu. Jtil’b pavuoqa ag wuvs jo rxa frfo ox nwe pdebp tqawu nnorovv xotqllurfoj rii iftanazij yirq @ApvumcobAwzoyt. An reofx gu tuka sa xiqa hzi HowHarwesPucxipi izrwqumcaop ad vpe mobehm hqgu inywuad.
2. Ul bso mogurs, @UmfabsecAvkubd godtaw awa @Jmuqen.

Key points

• Dagger has offered assisted injection since version 2.31.0.
• @AssistedInject allows you to tag the primary constructor with @Assisted parameters.
• To create an instance of @AssistedInject, you need an @AssistedFactory.