WEBVTT

1
00:00.840 --> 00:01.760
Bentornati.

2
00:01.800 --> 00:04.960
In questo video impareremo a conoscere i
moduli dell'elsa.

3
00:04.960 --> 00:10.560
Abbiamo già detto che i moduli hilt
servono a definire come vengono fornite le
dipendenze.

4
00:10.560 --> 00:16.480
Abbiamo usato il modulo di annotazione per
dire che questo oggetto fungerà da modulo
di elsa.

5
00:16.680 --> 00:23.280
In questo modo la classe verrà
contrassegnata come modulo per il
provisioning delle dipendenze.

6
00:23.400 --> 00:28.920
Abbiamo usato install in annotation e
abbiamo usato il componente singleton.

7
00:28.920 --> 00:32.520
Le dipendenze vivono in un ambito
singleton.

8
00:32.560 --> 00:38.280
Non preoccupatevi, nei prossimi video
impareremo a conoscere le annotazioni
sull'elsa.

9
00:38.280 --> 00:46.480
Ma vorrei che vi concentraste su come
creare il modulo dell'applicazione

10
00:46.480 --> 00:49.000
e fornire le dipendenze e definire come
vengono fornite le dipendenze.

11
00:49.000 --> 00:53.520
Iniziamo con la funzione fornire il
motore.

12
00:53.520 --> 00:57.800
Questa classe restituisce un oggetto
motore.

13
00:58.040 --> 01:00.400
Ok, questo è molto semplice.

14
01:00.440 --> 01:08.400
Ora, per dire a Hilt e al modello
dell'applicazione che dobbiamo fornire un
motore,

15
01:08.400 --> 01:14.440
dobbiamo usare l'annotazione provides;
l'annotazione provides dice a Hilt come
fornire un oggetto.

16
01:14.440 --> 01:18.160
Metodi annotati con l'annotazione
provides.

17
01:18.160 --> 01:24.360
Restituisce l'oggetto che sarà iniettato e
in questo caso dobbiamo iniettare il
motore.

18
01:24.360 --> 01:30.640
Se necessario, è possibile aggiungere
ulteriori logiche o configurazioni in
questi metodi.

19
01:30.640 --> 01:38.880
Fornisce l'annotazione utilizzata nei
moduli in cui non è possibile utilizzare
l'iniezione

20
01:38.880 --> 01:41.240
sul costruttore, ad esempio l'interfaccia
di librerie di terze parti e altre.

21
01:41.240 --> 01:45.480
In seguito vedremo questa annotazione in
molti esempi.

22
01:45.480 --> 01:51.160
Quindi, in seguito, utilizzeremo
l'annotazione provides quando l'iniezione
del costruttore non è possibile.

23
01:51.160 --> 01:57.240
Ad esempio, se la classe appartiene a una
libreria di terze

24
01:57.240 --> 01:59.040
parti, fornisce un'annotazione che aiuta a
creare e restituire la dipendenza.

25
01:59.040 --> 02:06.710
In questo caso, però, dobbiamo capire il
ruolo e l'obiettivo dell'utilizzo dei
provides,

26
02:06.710 --> 02:10.110
che è quello di restituire il motore che
verrà iniettato in seguito.

27
02:10.150 --> 02:16.110
Occorre quindi contrassegnare questa
funzione con un'altra annotazione,
chiamata Singleton.

28
02:16.150 --> 02:24.310
Singleton assicura che hilt fornisca una
singola interfaccia della dipendenza in
tutta l'applicazione.

29
02:24.350 --> 02:31.670
Singleton assicura che hilt fornisca una
singola istanza della dipendenza per
l'intera applicazione.

30
02:31.670 --> 02:38.350
Si usa con le classi fornite tramite
iniezione di costruttori o con i metodi
dei moduli.

31
02:38.390 --> 02:45.790
Gli oggetti annotati con l'annotazione
singleton vivono per l'intera durata
dell'applicazione.

32
02:45.830 --> 02:51.350
Non preoccupatevi, impareremo a conoscere
a fondo queste annotazioni nei prossimi
video.

33
02:51.350 --> 02:52.710
Perché usare Singleton.

34
02:52.710 --> 02:59.630
Se si vuole che una dipendenza viva
nell'applicazione e sia riutilizzata
ovunque, invece

35
02:59.670 --> 03:03.590
di creare una nuova istanza ogni volta che
si usa un singleton.

36
03:03.630 --> 03:08.950
La seconda funzione che dobbiamo creare è
la funzione provide car.

37
03:08.950 --> 03:10.550
Fornire l'auto.

38
03:10.710 --> 03:18.590
Qui dobbiamo passare un parametro del
motore e auto restituire auto e passare il
motore.

39
03:18.790 --> 03:27.550
Dobbiamo dire al modulo hilt che questo
metodo creerà e fornirà un'istanza della
classe car.

40
03:27.550 --> 03:33.590
Dobbiamo usare di nuovo l'annotazione
provides e l'annotazione singleton.

41
03:33.630 --> 03:34.030
Di nuovo.

42
03:34.030 --> 03:39.270
Ragazzi, questa annotazione contrassegna
il metodo come metodo fornitore.

43
03:39.270 --> 03:46.110
Indica a Hilt come creare un oggetto
quando l'iniezione del costruttore non è
sufficiente o non è possibile.

44
03:46.110 --> 03:51.990
In questo caso, dice a Hilt che questo
metodo fornisce un oggetto auto.

45
03:51.990 --> 03:53.870
Annotazione Singleton.

46
03:53.990 --> 04:01.870
Questa annotazione assicura che venga
creata e percorsa una sola istanza

47
04:01.910 --> 04:05.030
di auto durante il ciclo di vita
dell'applicazione, ovvero l'ambito
singleton.

48
04:05.070 --> 04:11.950
Senza singleton, verrebbe creata una nuova
istanza di auto ogni volta che viene
richiesta.

49
04:11.990 --> 04:17.030
Ancora una volta, ragazzi, queste note e
commenti sono molto importanti.

50
04:17.030 --> 04:23.950
Voglio che li scriviate perché sono molto
importanti per

51
04:23.950 --> 04:25.510
memorizzare ogni codice e ogni singola
riga di codice.

52
04:25.550 --> 04:28.870
Di nuovo ragazzi, come usare questo
codice? Hilt

53
04:28.910 --> 04:33.750
risolve innanzitutto la dipendenza dal
motore dei parametri.

54
04:33.790 --> 04:38.430
Hilt utilizza l'iniezione, l'annotazione o
altri strumenti.

55
04:38.470 --> 04:45.790
Ad esempio, per il metodo di annotazione
provides, per

56
04:45.790 --> 04:46.510
creare un'istanza del motore, se non è già
disponibile.

57
04:46.510 --> 04:50.430
Quindi forniamo un'istanza di scheda.

58
04:50.430 --> 04:58.910
Una volta che Hilt ha l'istanza del
motore, chiama il metodo provide card per
creare un'istanza di carta.

59
04:58.910 --> 05:07.420
L'oggetto carta risultante è memorizzato
in un ambito singleton,

60
05:07.420 --> 05:10.380
grazie all'annotazione singleton, quindi
sarà riutilizzato ovunque sia necessario.

61
05:10.420 --> 05:12.980
Ecco come funziona l'elsa.

62
05:12.980 --> 05:16.580
Per ricapitolare rapidamente ciò che
abbiamo fatto in questo video.

63
05:16.620 --> 05:19.980
Abbiamo creato la parte più importante,
ovvero il modulo dell'applicazione.

64
05:20.260 --> 05:24.900
La prima cosa da fare per il flusso di
esecuzione è la richiesta di auto.

65
05:25.060 --> 05:29.900
Quindi una classe o una funzione da
qualche parte nell'applicazione richiede
un oggetto auto.

66
05:30.060 --> 05:32.820
Hilt risolve le dipendenze hilt.

67
05:32.820 --> 05:42.060
Per prima cosa, verificare come fornire
l'oggetto motore tramite l'annotazione
inject o l'annotazione provides a.

68
05:42.060 --> 05:49.060
Quindi hilt cerca l'annotazione inject o
provides nel modulo dell'applicazione.

69
05:49.300 --> 05:55.820
Hilt chiama quindi l'auto provide con
l'istanza del motore risolta come
parametro.

70
05:55.860 --> 05:57.380
Il comportamento dei singleton.

71
05:57.380 --> 06:01.180
Poiché viene utilizzato Singleton, viene
utilizzata l'annotazione Singleton.

72
06:01.220 --> 06:06.140
La stessa istanza di auto viene
riutilizzata ogni volta che viene
richiesta.


