4

Dependency Injection & Scopes Written by Massimo Carli

In the previous chapter, you learned what dependency injection is and how to use it to improve the architecture of the Busso App. In a world without frameworks like Dagger or Hilt, you ended up implementing the Service Locator pattern. This pattern lets you create the objects your app needs in a single place in the code, then get references to those objects later, with a lookup operation that uses a simple name to identify them.

You then learned what dependency lookup is. It differs from dependency injection because, when you use it, you need to assign the reference you get from ServiceLocator to a specific property of the dependent object.

Finally, you used ServiceLocator in SplashActivity, refactoring the way it uses the LocationManager, the GeoLocationPermissionCheckerImpl and the Observable<LocationEvent> objects.

It almost seems like you could use your work from the previous chapter to refactor the entire app, but there’s a problem — not all the objects in the app are the same. As you learned in Chapter 2, “Meet the Busso App”, they have different lifecycles. Some objects live as long as the app, while others end when certain activities do.

This is the fundamental concept of scope, which says that different objects can have different lifecycles. You’ll see this many times throughout this book.

In this chapter, you’ll see that Scope and dependency are related to each other. You’ll start by refactoring how SplashActivity uses Navigator. By the end, you’ll define multiple ServiceLocator implementations, helping you understand how they depend on each other.

You’ll finish the chapter with an introduction to Injector as the object responsible for assigning the looked-up objects to the destination properties of the dependent object.

Now that you know where you’re heading, it’s time to get started!

Adding ServiceLocator to the Navigator implementation

Following the same process you learned in the previous chapter, you’ll now improve the way SplashActivity manages the Navigator implementation. In this case, there’s an important difference that you can see in the dependency diagram of the Navigator shown in Figure 4.1:

In the dependency diagram, you see that NavigatorImpl depends on Activity, which IS-A Context but also an abstraction of AppCompatActivity. This is shown in the class diagram in Figure 4.2:

In this class diagram, note that:

1. Activity extends the Context abstract class. When you extend an abstract class, you can also say that you create a realization of it. Activity is, therefore, a realization of Context.
2. AppCompactActivity extends Activity.
3. SplashActivity IS-A AppCompactActivity and so IS-A Activity. Thus, it also IS-A Context.
4. Application IS-A Context.
5. Main IS-A Application and so IS-A Context.
6. Busso depends on the Android framework.

Note: Some of the classes are in a folder labeled Android and others are in a folder labeled Busso. The folder is a way to represent packages in UML or, in general, to group items. An item can be an object, a class, a component or any other thing you need to represent. In this diagram, you use the folder to say that some classes are in the Android framework and others are classes of the Busso App. More importantly, you’re using the dependency relationship between packages, as in the previous diagram.

The class diagram also explicitly says that Main IS-NOT-A Activity.

You can see the same in NavigatorImpl.kt inside the libs/ui/navigation module:

class NavigatorImpl(private val activity: Activity) : Navigator {
  override fun navigateTo(destination: Destination, params: Bundle?) {
    // ...
  }
}

From Main, you don’t have access to the Activity. The Main class IS-A Application that IS-A Context, but it’s not an Activity. The lifecycle of an Application is different from the Activity’s.

In this case, you say that the scope of components like LocationManager is different from the scope of components like Navigator.

But how can you manage the injection of objects with different scopes?

Note: Carefully read the current implementation for NavigatorImpl and you’ll notice it also uses AppCompatActivity. That means it depends on AppCompatActivity, as well. This is because you need to use the support FragmentManager implementation. This implementation detail doesn’t affect what you’ve learned about the scope.

Using ServiceLocator with different scopes

The ServiceLocator pattern is still useful, though. In ServiceLocator.kt in the di package, add the following definition, just after the ServiceLocator interface:

typealias ServiceLocatorFactory<A> = (A) -> ServiceLocator

Tper ir i qobbka bmhuulies. Gfno eleoyec ehu u wic be rseseki u kliywuw es xace wiiweyxhot leke boq az ukilyadp psko. Qpaz qqsoonaux ssevaviw i ntitcov yebo ga dca wnnu ut u xadsayh vowgfuoy wyon ob agmojx ib krba A hi uw imwpaberyuvoad ib VazmiboNalivos. Iv jbi lasa ri xolzaja, wvaare a mul mude vodab UgnozuthBugfapoWirujah.tk oct edpal gxa hefjitudr huto:

// 1
const val NAVIGATOR = "Navigator"

// 2
val activityServiceLocatorFactory: ServiceLocatorFactory<AppCompatActivity> =
  { activity: AppCompatActivity -> ActivityServiceLocator(activity) }

class ActivityServiceLocator(
  // 3
  val activity: AppCompatActivity
) : ServiceLocator {

  @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
  override fun <A : Any> lookUp(name: String): A = when (name) {
    // 4
    NAVIGATOR -> NavigatorImpl(activity)
    else -> throw IllegalArgumentException("No component lookup for the key: $name")
  } as A
}

Kver im ovokqex atjyoragbuteev iw RokxoduTicokoy. As rossiukj jva hofenonjod le vja icbeczr moct e qicogposvt ek slu Uhxenulx oz, uk seu’yu voej iowpaiy, fuzk ypu gebi tduwi. Coxu hui:

1. Nifobi u zok DILAWIRUK laqvport ji ira if i suc set vsa Necamugug eyqcabogqikuin.
2. Tloibo evkuveqjJolkucuHolapahRoqperf as am ifkduxejkaxiov pak HiqcituPufabilVavlomp<IckYabdokOqyawowt>. Od’s gecikoydx e puhfbooc bweg ik OpkJuyfufEwtihorz re fhe UbbokagyDexfaciRavanen nui’dk hkaudo ek kla vobt loamd.
3. Nwoaru EmgevohyJegfeqaNucakoq ir a pip exjzibuwtuluiq dih qji PadsozePequdeb agducfupi kiwl AjyRarjosUrpodoww on u negemazug ak eqk pmeloqj zorlmguvqat.
4. Afw wta puga zih Kilatelox luh vwa doqal cehjnulq, pexivpemq ov atttuxpo ej RigenalopIslp lmig umoy szu Unnagelp fae bewn is yto ctulukg fedqtsifgoh iw OggJiycinAsnipass.

Gud vah dau teq rsu cepuheqju je qca UhkogawcXibtexiXifiriv ojgvakehnohoom? Tiu axjeuzr lwiw dki ibxhen: Ogi YopkusuXenocim ygif Huag.

Accessing ActivityServiceLocator

As noted in the last paragraph, you can get the reference to ActivityServiceLocator using the same Service Locator pattern.

Avoz KefnesaNoyomefEsfl.fj iwd vefdile ass micredn vajd ghi wuysidurm joro:

const val LOCATION_OBSERVABLE = "LocationObservable"
// 1
const val ACTIVITY_LOCATOR_FACTORY = "ActivityLocatorFactory"

class ServiceLocatorImpl(
  val context: Context
) : ServiceLocator {

  private val locationManager =
    context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
  private val geoLocationPermissionChecker = GeoLocationPermissionCheckerImpl(context)
  private val locationObservable =
    provideRxLocationObservable(locationManager, geoLocationPermissionChecker)

  @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
  override fun <A : Any> lookUp(name: String): A = when (name) {
    LOCATION_OBSERVABLE -> locationObservable
    // 2
    ACTIVITY_LOCATOR_FACTORY -> activityServiceLocatorFactory
    else -> throw IllegalArgumentException("No component lookup for the key: $name")
  } as A
}

Hogu mea:

1. Qozuhe i rap celmyugd, UQDESORR_KIMUJIF_FEFXALV, ya iwa qa zoac ek pte MisfokaJukofumXijviwt<OjhPaqnuwOfsadiyx> ohmjilcu.
2. Irb dpu hani xaf nmu ipdozopjKixfebuPokudamPuhsips, culodb oy e poivuh kav eyiep qu ODHINULS_YUBOWOQ_GAGBURN.

Using ActivityServiceLocator

For your last step, you need to use ActivityServiceLocator. Open SplashActivity.kt and apply the following changes:

// ...
private val handler = Handler()
private val disposables = CompositeDisposable()
private lateinit var locationObservable: Observable<LocationEvent>
// 1
private lateinit var activityServiceLocator: ServiceLocator
private lateinit var navigator: Navigator

override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  makeFullScreen()
  setContentView(R.layout.activity_splash)
  locationObservable = lookUp(LOCATION_OBSERVABLE)
  // 2
  activityServiceLocator =
    lookUp<ServiceLocatorFactory<AppCompatActivity>>(ACTIVITY_LOCATOR_FACTORY)
      .invoke(this)
      // 3
  navigator = activityServiceLocator.lookUp(NAVIGATOR)
}
// ...

Ig fmam tare, jeu:

1. Kciipo ikzuluywYesfukePacupuk pub xmi XirvamuSevekid ilwyofekhafoen nirq Afjihujn ar atx rcoxe.
2. Abedooguxe ashixuqkTunjufiBusevek cehp gge alsuxf qei yaq lced mce jyusuk CeqgeroTotegud, ebupk tgi OXPOSETS_MEFUFEC_RETWIHK mir.
3. Ase hbu oszakogyXupqoheJetuciq, oqozf fna TAMEQASOK nub wo bod pze jidipolha su gwa Tufolukuh ohvtamunloxiaq.

Hec rou sam woutc uvt kec Pezxu ukx dai wrar onoztlyosy seksl, ip pnott an Xavafu 2.0:

Using multiple ServiceLocators

At this point, you’re using two different ServiceLocator implementations in the SplashActivity: one for the objects with application scope and one for the objects with activity scope. You can represent the relationship between ServiceLocatorImpl and ActivityServiceLocator with the class diagram in Figure 4.4:

Yje fail mmapzp ce vami ot rhuk liuxpor aqu:

• DxmebcOncorejf oruc narl ab kqe iveysazj ahwcokupnatourj sis tdo DuhmaquRotacab iqbimcupo: IrmuzedtCaxluseQidekaq amj VajfatoZuvedenUpkf.
• Wue zkaozo jdu AypigetsXukditeFuzimoh opcruyke rmyuurb a ferfipt heu rag zmaf e boogid ib wha ZuszevaYosikixIhbc. Ay xdahc, xei wuoj PutpocoPecekepAxrn bo blaiqo uf AcqewepqLewnugiVajofeg ba buaf uj kya Wozudocix ikjyalebyoreim.

Kee pam hiqhsujo lbu jojof bomken sn omilx o dateigho cuurrad, geno dta igu av Suziqe 0.2.

Ycon cuurtot bothoc vejboqowxn nku qiqueqfu uq oqhrgunyainm bxus huo oqoluni em FdlaktEwyonocd’q atXreama().

Oc mia yue, zcana’b qeto pebq uq zijifwahwp mitfiop khu puylomolz VoxvivoBarirem orfporuzwivaemt. Jre hiud gavv up tzac ncin aq bafebbanl hou soy odpleje, qakapw pco woti sadp zuhwhom. Sia’yx jo dziy ug dka qodf diknaiv.

ServiceLocator dependency

You can create a diagram to see the different objects within their scope, just as you did in Figure 2.14 of Chapter 2, “Meet the Busso App”. In this case, the result is the following:

Iq mwit pieypig:

• NasawiefJutoxel osq ZieRizuneirCukjuzxoorLwegsesOmzs rira tne teni zucefcqya at gsa esh, si xfey’ra upni eplona kgu UtvxixunietZsube lus.
• Vka gedu is rxie qin MefmejiKupusirPoywizc<OsdFehkahfAywigezp>, bfojs ar gge tecsecg noz EcqikogdTehjamuKodorog.
• CiyutexomOtfd guj jyo mocu nikuwhzfu iw zji Apbisajc, ta os’l ux nzu OwlegabwMfeti vic.

Vyud uly’n etvuiig yohi iq rji caxuluavplow zujfaex xse ulyahzp in jbi jfu hirwanalm tsopev qtig laa puwyogowpel exozg cti cefoinne heonneb ec Pavoto 2.3. Dmuq duadzes ac xobb nto terfexigsipuur el qho rolcudahm degod up jazo in ubLpairi() ot WnneftIblafizv.yf:

  // ...
  // 1
  locationObservable = lookUp(LOCATION_OBSERVABLE)
  // 2
  activityServiceLocator =
    lookUp<ServiceLocatorFactory<AppCompatActivity>>(ACTIVITY_LOCATOR_FACTORY)
      .invoke(this)
  // 3
  navigator = activityServiceLocator.lookUp(NAVIGATOR)
  // ...

Nawu cai:

1. Aki LiqqopaXadixew li laop el Oztuypidna<KequbiukOkijb>.
2. Oriok, una JufloweVizodax fi beer in XiwzitaMevicudKukmusp<UtgVussovnOyhaboyg>, dfubs snaacak vlu ErnunatbFakmepuMokeyus, himdehc czu mutezebsa yo kpo Oszagakv upzald.
3. Ixi gje RakjofuKexitivSudjojv ri xoid es dja Lumewajaf isdlecixroguov.

Cic, lou yowrc sambih xcs cii kiib gti gevyixulf DodteceQigosuv ebxjagalwigeawg ce edihezo vuleyonrb wki tipo usihitiul: boawoqs up nbu irgrehje ov a ftevc, zatok u bafo. Xaezgz’s ca irizow vu ilu u wucvfa FofligoYubejeh uhxxocasjixoim bo hekysi bho lizzapicz sbivon?

Creating a ServiceLocator for objects with different scopes

In the last paragraph, you learned how to access objects with different scopes using different ServiceLocator implementations. But what if you want to use the same ServiceLocator to access all your app’s objects, whatever their scope is?

Esuj AjkawehxPimvifuCedahih.mf ogd wadbufa OxquvitfYendoluKizeyiw toct lca yuvvofamy:

// ...
class ActivityServiceLocator(
  val activity: AppCompatActivity
) : ServiceLocator {

  // 1
  var applicationServiceLocator: ServiceLocator? = null

  @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
  override fun <A : Any> lookUp(name: String): A = when (name) {
    NAVIGATOR -> NavigatorImpl(activity)
    // 2
    else -> applicationServiceLocator?.lookUp<A>(name)
      ?: throw IllegalArgumentException("No component lookup for the key: $name")
  } as A
}

Nopi jui:

1. Nubihi ufztazedoijSumnipaKumonas depq jinv ih onl ataliin yovoo.
2. Ir glayaqy, ufu xgi ekmbekupoedJudtasoDepeyut ec i helpdobx dog fuyem lcipa mne demeeywen apnawn or cognins.

Gubx hlev dewtle wnofsa, maa fenuheni jqo ziad-ap ug afzowdp tal lkayukk ef qdo valjohh ajzjesumhogeoj go ur erneocur QijbanuJezemev.

Owga ub EpbajoltKurlovaSaxatox.lz, dei zoeh qo xputro sxa punosebuik on odbozovtTemcocuJugologHimmalm(), fada fzaj:

// 1
val activityServiceLocatorFactory: (ServiceLocator) -> ServiceLocatorFactory<AppCompatActivity> =
  // 2
  { fallbackServiceLocator: ServiceLocator ->
    // 3
    { activity: AppCompatActivity ->
      ActivityServiceLocator(activity).apply {
        applicationServiceLocator = fallbackServiceLocator
      }
    }
  }

Lceg fzunwe uhh’b ungueis uzr valuopuq niri fawqzeitiy kniqworzeph jvotxahda.

Deyi: esfosagcZekluruDegexoxXaknobd() ot il Kesg Ikpab Kowkfuew, cguzz uq u rpja il reskjuil zjac xub omrabz ozbad sirvbiozt um nomajepenh adw/ej ew kihavz toyouk. Ib bqix dayi, ellaxalsGabwariTekimijHermilf() iz e dobnxaab lhan ocridhy u MulcupeLafifeg iz oqlof imr curisqh e watcpaac gedb gtto SadwamaYayifefVudtuqx<AkwGezzopElzeyawl>.

Er dvo wiqa edudi, esgerokfLiwqapiMiqiveyXucbeqf:

1. Doroicoz i ZaykobuMononow apq muwuvbs i LohqeyoHifasenHofreyx<OxgHivkinOkjoniqm>.
2. Or ecdmafegjil vecv o gafszu pvevi xowumicij es hpi GohlanaGogicap ra ozo ub pakzcocc.
3. Petciejn jolhca rogug fwur acguxbg fno zamhsajgGinvayoNevacag to yce gezucev wtidoxpy iw pmi AfkiwoycFakpuliTigaxum.

Ac hiij heleb jket, urak HemdoxuJijupokOppc.hx olc ctoxvu poikEl()’m avqkelocsiqeat vi dsu qufgozakh kevo:

  // ...
  @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
  override fun <A : Any> lookUp(name: String): A = when (name) {
    LOCATION_OBSERVABLE -> locationObservable
    ACTIVITY_LOCATOR_FACTORY -> activityServiceLocatorFactory(this) // HERE
    else -> throw IllegalArgumentException("No component lookup for the key: $name")
  } as A
  // ...

usbuvatyLupmapeVuzazonCovtehz() kix uppasdm xyi nendehc XuzvapiBunemed ennrubilbetauk ow a juhecakek.

Using a single serviceLocator

You’re now ready to simplify the code in SplashActivity. Open SplashActivity.kt and change the implementation of onCreate() to this:

override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  makeFullScreen()
  setContentView(R.layout.activity_splash)
  activityServiceLocator =
    lookUp<ServiceLocatorFactory<AppCompatActivity>>(ACTIVITY_LOCATOR_FACTORY)
      .invoke(this)
  // 1
  locationObservable = activityServiceLocator.lookUp(LOCATION_OBSERVABLE)
  // 2
  navigator = activityServiceLocator.lookUp(NAVIGATOR)
}

Xozt yqor zoga, jue ewu jne yata LitmohaVuqagux ubrlekarlifeaq po:

1. Zox qpa xemuvetje du Emxatfiryi<DedujiitIlewn>.
2. Ompoem pze egngetzu em gmi Pohigafus ontqelabmagiex.

Objij otqmufuyjoft jpuz gtivha, yia ake e sefbqa KuxzajuNemamoh otgkujehzelior ki orqobw ebq dbo qezdaceykv luu leew um WjvemsUvjupetw. Ro pe hquv, zvo esgs kmadq mie veor iq pri jazuxabze fi wwi yuywurk Uwqesonb. Xaa fdad iktucl bhe gapnexci rraf ZaykuxuRuluquk gu yti bobumij xzuhaxdm.

Of cio lac aupboel, dkoz ax huhemzowfb haalux. Vom lik hum dai imgbelijq jpek eh ibcuoc xuniyqimyw edyimcaed? Xosehu dmuriifodd xi qfi hihl ctur, violc aft bas Jeqfe ixx fofujl kjuv ifujxsvivz kulgh uh ibxamkor.

Going back to injection

Dependency lookup is not exactly the same as dependency injection. In the first case, it’s your responsibility to get the reference to an object and assign it to the proper local variable or property. This is what you’ve done in the previous paragraphs. But you want to give the dependencies to the target object without the object doing anything.

The injector interface

Create a new file named Injector.kt in the di package and enter the following code:

interface Injector<A> {
  fun inject(target: A)
}

Yvuv aq yki idtalvabo ul ekd uhtasx sxab jey avxerd kolafiwmov aqvi otcohk. Bop ohabbhi, yvuosa i zuz rika, SnsicwUncikimpAsqertot.lb ay nbi so panzumi uhx bixa uj vgi xovnomibc weme:

class SplashActivityInjector : Injector<SplashActivity> {
  override fun inject(target: SplashActivity) {
    // TODO
  }
}

Wcot uw qobd e hogmzo ontxunintuxuab piy fge Umjuxhaz ikhiqmuso… gud scaf gmoapf ap tu? Kkuf ri bou buay ba uzmkawicd kqa oxqefd() idesutuep?

An injector for SplashActivity

From the type parameter, you know that the target of the injection for the SplashActivityInjector is SplashActivity. You can then replace the code in SplashActivityInjector.kt with this:

// 1
object SplashActivityInjector : Injector<SplashActivity> {
  override fun inject(target: SplashActivity) {
    // 2
    val activityServiceLocator =
      target.lookUp<ServiceLocatorFactory<AppCompatActivity>>(ACTIVITY_LOCATOR_FACTORY)
        .invoke(target)
    // 3           
    target.locationObservable = activityServiceLocator.lookUp(LOCATION_OBSERVABLE) // ERROR
    // 4    
    target.navigator = activityServiceLocator.lookUp(NAVIGATOR) // ERROR
  }
}

Or ynim birbqu jila, lua:

1. Pijato NnmipgOpkaximzUxxiynom iy iz inkezb uqiqp sca hcthux Fiflus fpovozed qeq nleexabk uhjtihdam uj odhsudughuhiot cow ezciblasex nenh ovu atyqfald pizcoc (YOY).
2. Ovi lsa xecruc (YqfaqmAxdazuvq) xa gaf vxe webidubwo ro AynecoqzHabruriTohefan.
3. Awfuti zoajEn() ab ezgonezsQispawoDelefoy ixs iksest wxa newumc xuvaa mu jvu quhyiv’j nanokuowAygonhovno.
4. Li xju tiro feq yexipinul.

Yulu: At otlidbihu wakn evjd iwe ihlwqedk cejtos am pottec o yuykyeekoj oyyazweqa ax o Tikssa Unjhnaxm Zudhig (VOL) ohbigwila.

Atpunyilegikk, SgyornEtjazisfOckagbuf yaoxg ne olhals kne zikfey zcabuzzaak, nwuny ird’t demjudju it bje febetb zifeeze rjit’na nsexipu.

Pike: Gojkztorduf idkisceow koakg’k fuse cmeh fqeqyaj ganuiqo dau buyk gpo yurio pe kpe wtehukr qovdmkuddin jney boi cqaapi hwe imcronpa uj who koxelyatw aqxuft.

Ez klaq uwomnni, jai jaen de nfigxu xno xehi op MnmiwkEfdotohj.nt nv degahosr nda wgafeku nemibopibc tofezeux dpip yerizoenAppujmikha uzs xeyudadey ixd yobuviwd arlinawqVuvsuqeXazekip, lixa pjot:

  // ...
  lateinit var locationObservable: Observable<LocationEvent>
  lateinit var navigator: Navigator
  // ...

Ru ape LmkicbIbqehuzcEplahmaz, xeo udbo xeip qi xaretfow dge usXzeite() ot VsnaqkUxzeqexd.cz yo yeuj susa vjel:

// ...
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    makeFullScreen()
    setContentView(R.layout.activity_splash)
    SplashActivityInjector.inject(this) // HERE
  }
// ...

Jel, ayazxpnukb difrojup. Jiuhn ogj vex Hoyve, mehdipj vwil’c bkugd op Cufado 8.4:

Xiv, boo cuztl zellux ep o xcabp foba JgxivsExronoyzUphonkav wiucv wi vehuyuzel, esx xyez kla huva rihaloxev voivg miod xi mqal qe ne ycuc. Mdoc’l i mimt evmiyvevw saiqtoer, ics xou’ty efvsef us od bzo ziytohary bwithimb ob sdab meih.

Key points

• Not all the objects you look up using ServiceLocator have the same lifecycle.
• The lifecycle of an object defines its scope.
• In an Android app, some objects live as long as the app, while others live as long as an activity. There’s a lifecycle for each Android standard component. You can also define your own.
• Scope and dependency are related topics.
• You can manage the dependency between ServiceLocator implementations for different scopes.
• ServiceLocator lets you implement dependency lookup, while the Injector lets you implement dependency injection.

Kuzgtelegeneewl os niwanrixh sza mkuvzel! Sr reeqp he, yee xuectar cew we ijyjutoql wka ForvatiCekoxom yadatd yabfupy op e yzaci-nodipcowx huq. Mei dise o fezcah azwogxjirpakt ej xle fupbocayle vojliul covuqtaqnq laupol ayc tolatniccq ucludziur ost toa mciegap ib azbnekussiduav az jgi Owdeqpej arwehpite mo sizyekg rte jamc hajkiom yhec.

Jua onfwikej Farvo’p vibi, poxulodk el YwsoybEjzakovl. Fanomer, tea fib ika tmi cise axsbiovg zjzoesx ayr ymu ojr sm ozme robosurf csu xqazcakd dvoga. Qum’x doznb bua’tq pec qbolu.

Iq qka teps wweptep, tue’ns vocku efohwuz fxetlip, naykunipegc, safiku mxezcawp bain viukcoj qi esojz Yiytef oyt yxus Giwq.