WEBVTT

1
00:00.770 --> 00:02.000
Bentornati.

2
00:02.030 --> 00:09.950
Dopo aver introdotto l'architettura MVVM e
il database delle stanze, è il momento

3
00:09.980 --> 00:12.890
di iniziare a costruire la nostra nota,
che è un'applicazione per prendere
appunti.

4
00:12.890 --> 00:19.820
In questa applicazione, seguiremo
l'architettura MVVM e otterremo i dati da
un'origine

5
00:19.820 --> 00:26.360
dati locale, non da un'origine dati
online; nei prossimi video e

6
00:26.360 --> 00:28.700
nelle prossime sezioni e nella prossima
applicazione, utilizzeremo un'origine dati
remota.

7
00:28.730 --> 00:34.370
In questa applicazione, utilizzeremo
l'origine dati locale, ovvero il database
della stanza.

8
00:34.370 --> 00:38.090
Abbiamo tre livelli: il modello, il
modello della vista e la vista.

9
00:38.090 --> 00:42.140
Come ho detto, l'architettura MVVM separa
i codici.

10
00:42.140 --> 00:48.680
Quindi il modello, che è un livello
responsabile dell'astrazione delle fonti
di dati, lavora

11
00:48.680 --> 00:52.700
insieme al modello della vista per
ottenere e salvare i dati e la vista.

12
00:52.730 --> 00:57.920
Lo scopo di questo livello è informare il
modello di vista sull'azione dell'utente.

13
00:57.920 --> 00:59.930
Quindi se l'utente fa clic su un pulsante.

14
00:59.960 --> 01:00.680
Pulsante di salvataggio.

15
01:00.680 --> 01:01.560
Pulsante di cancellazione.

16
01:01.590 --> 01:02.610
Pulsante di aggiornamento.

17
01:02.610 --> 01:09.210
Questo livello osserva il ViewModel e non
contiene alcun tipo di logica applicativa.

18
01:09.240 --> 01:10.320
Il ViewModel.

19
01:10.320 --> 01:14.910
Espone i flussi di dati rilevanti per la
vista.

20
01:14.940 --> 01:22.140
Inoltre, funge da collegamento tra il
modello e la vista e all'interno del
database della

21
01:22.140 --> 01:27.600
stanza abbiamo le tre parti della classe
entità, del Dao e del database stesso.

22
01:27.600 --> 01:31.710
Inizieremo con questa parte e poi
passeremo al repository.

23
01:31.740 --> 01:33.540
Finiamo il modello.

24
01:33.540 --> 01:38.040
Poi passeremo alla parte ViewModel e
quindi alla vista.

25
01:38.070 --> 01:44.670
Seguendo questa architettura, si
costruisce un'applicazione con
un'architettura professionale

26
01:44.670 --> 01:48.570
pulita, utilizzata dagli sviluppatori
professionisti di tutto il mondo.

27
01:48.600 --> 01:54.090
Passiamo ad Android Studio e iniziamo a
costruire la nostra applicazione per le
note.

28
01:54.120 --> 02:01.230
Aprite Android Studio e create un nuovo
progetto di composizione ed eliminate le
funzioni componibili.

29
02:01.260 --> 02:03.460
Rimuovere questa impalcatura.

30
02:03.460 --> 02:04.570
Ed eccoci qui.

31
02:04.600 --> 02:09.040
Ora aggiungiamo la dipendenza del
database.

32
02:09.070 --> 02:13.060
Andate sul sito web di Android
developer.android.com.

33
02:13.060 --> 02:20.440
Slash jetpack slash Android X slash
releases slash room o semplicemente
cercare la dipendenza dal database delle
stanze.

34
02:20.470 --> 02:28.540
Ancora una volta, la libreria Room
Persistence fornisce un livello di
astrazione su SQLite per

35
02:28.540 --> 02:35.080
consentire un accesso più robusto al
database, sfruttando al contempo tutta la
potenza di SQLite.

36
02:35.110 --> 02:41.710
Per aggiungere la dipendenza da room, è
necessario aggiungere il repository di
Google Maven

37
02:41.710 --> 02:44.230
al progetto, che è incluso in modo da
poter selezionare Groovy o Kotlin.

38
02:44.230 --> 02:49.300
Siamo interessati all'uso di Kotlin perché
state usando Android Studio.

39
02:49.330 --> 02:53.200
Copiare in questa riga la versione e
l'implementazione.

40
02:53.200 --> 02:57.370
Andare all'applicazione modulo script di
Android Studio Gradle.

41
02:57.370 --> 03:02.410
Scorrere verso il basso e aggiungere il
database della stanza.

42
03:02.410 --> 03:06.010
Questa è la versione della stanza e questa
è l'implementazione.

43
03:06.040 --> 03:10.120
Il secondo passo consiste nell'utilizzare
un processore di annotazioni.

44
03:10.120 --> 03:12.280
Ne abbiamo tre tipi.

45
03:12.280 --> 03:21.460
Il processore di annotazioni, il
processore di annotazioni Kapt e KSP sono

46
03:21.460 --> 03:25.150
utilizzati per generare codice,
convalidare le annotazioni e semplificare
lo sviluppo.

47
03:25.150 --> 03:30.940
Ne abbiamo tre tipi: il processore di
annotazioni, il Kapt e i plugin KSP.

48
03:30.940 --> 03:38.050
Il primo è il processore di annotazione,
utilizzato

49
03:38.050 --> 03:41.290
per generare file sorgente aggiuntivi o
altre risorse.

50
03:41.290 --> 03:49.900
Sulla base di queste annotazioni, il
processore di annotazioni lavora
all'interno

51
03:49.900 --> 03:57.250
del compilatore Java Javac, analizzando il
codice sorgente alla ricerca di

52
03:57.250 --> 03:57.910
annotazioni specifiche e generando codici
corrispondenti come factory, stub e altro.

53
03:57.940 --> 04:06.740
Il plugin Kapt, utilizzato per lo
strumento di elaborazione delle
annotazioni di Kotlin,

54
04:06.740 --> 04:15.080
consente a Kotlin di utilizzare i
processori di annotazioni Java esistenti,
permettendo alle

55
04:15.080 --> 04:16.700
librerie scritte per l'elaborazione delle
annotazioni Java di essere utilizzate nei
progetti Kotlin.

56
04:16.700 --> 04:19.790
L'elaborazione dei simboli KSP Kotlin.

57
04:19.820 --> 04:28.640
KSP è stato progettato per fornire un modo
più efficiente e idiomatico per
l'elaborazione

58
04:28.640 --> 04:37.070
delle annotazioni in Kotlin, offrendo
prestazioni migliori e una sintassi più
semplice rispetto a

59
04:37.070 --> 04:45.620
quella di Cap specificamente adattato a
Kotlin; elaborerà direttamente il codice
sorgente Kotlin, eliminando

60
04:45.620 --> 04:48.260
la necessità di stub Java intermedi,
migliorando così la velocità e riducendo
l'overhead.

61
04:48.290 --> 04:53.930
Il modo migliore è usare KSP, ma KSP è
ancora in fase di sviluppo.

62
04:53.930 --> 04:59.210
Non lo useremo perché molte librerie non
supportano KSP.

63
04:59.240 --> 05:03.780
Utilizzeremo Kapt, che è uno strumento di
elaborazione delle annotazioni di Kotlin.

64
05:03.780 --> 05:06.330
Ed è meglio di un processore di notazione.

65
05:06.330 --> 05:09.600
Quindi lo copierò e lo incollerò qui.

66
05:09.600 --> 05:12.270
Abbiamo un errore perché non abbiamo il
tappo.

67
05:12.270 --> 05:18.270
E per integrare Cap nel nostro progetto è
sufficiente utilizzare l'ID qui.

68
05:18.270 --> 05:28.170
All'interno dei plugin utilizziamo il
cappuccio di Kotlin e qui applichiamo

69
05:28.170 --> 05:28.770
il vero incluso tra le doppie virgolette
ora e qui andiamo.

70
05:28.770 --> 05:30.870
Ora possiamo utilizzare Kotlin.

71
05:30.870 --> 05:36.240
Un'ultima cosa da aggiungere è
l'estensione per le coroutine.

72
05:36.240 --> 05:38.280
Dobbiamo aggiungere le coroutine.

73
05:38.280 --> 05:39.720
Quindi copiate questo.

74
05:39.720 --> 05:46.860
Scorrete ora la sincronizzazione e usatela
perché useremo le coroutine con la stanza.

75
05:46.860 --> 05:49.920
Ecco quindi l'implementazione della
stanza.

76
05:49.920 --> 05:54.240
Qui abbiamo il processore di annotazioni,
perché utilizzeremo il database della
stanza.

77
05:54.240 --> 06:00.930
Dipende dalle annotazioni e dalle
coroutine per rendere le attività in
background