WEBVTT

1
00:00.800 --> 00:07.220
Quindi, come abbiamo pianificato in
precedenza, inizieremo con la sezione
dell'origine dati locale, che è il
database della stanza.

2
00:07.220 --> 00:12.020
Poi ci sposteremo nel repository per
completare la sezione del modello.

3
00:12.020 --> 00:17.540
Poi passeremo a creare il livello del
modello di vista e successivamente il
livello di vista.

4
00:17.540 --> 00:22.760
All'interno del database della stanza
dobbiamo iniziare con l'entità Dio.

5
00:22.760 --> 00:26.210
E poi con il database SQLite.

6
00:26.210 --> 00:32.300
Voglio che vi concentriate su di me e mi
seguiate passo dopo passo per implementare

7
00:32.300 --> 00:37.670
il database delle stanze e l'architettura
MVVM in qualsiasi applicazione che
dobbiate creare in futuro.

8
00:37.670 --> 00:40.280
Cominciamo con l'entità.

9
00:40.880 --> 00:48.170
Una classe entità definisce una tabella e
ogni istanza di questa classe rappresenta
una riga nella tabella del database.

10
00:48.170 --> 00:56.840
La classe entità ha delle mappature che
indicano a una stanza

11
00:56.840 --> 00:57.770
come intende presentare e interagire con
le informazioni del database.

12
00:57.770 --> 01:04.730
Immaginiamo di avere una tabella
contenente quattro colonne: nome ID,
prezzo e quantità.

13
01:04.730 --> 01:07.780
Questi sono i campi dell'entità o le
colonne.

14
01:07.780 --> 01:09.820
Il nome della tabella è item.

15
01:09.820 --> 01:17.740
Per rappresentarlo in Android Studio, è
necessario creare una classe con un nome
di elemento.

16
01:17.740 --> 01:22.060
Quindi il nome della classe sarebbe
l'elemento che rappresenta il nome della
classe dell'entità.

17
01:22.060 --> 01:26.380
E non mancate di annotarlo con
l'annotazione Aggiungi entità.

18
01:26.380 --> 01:30.520
Non preoccupatevi, lo vedremo nei prossimi
minuti.

19
01:30.550 --> 01:35.770
Per chiarire, dobbiamo creare una tabella
con un nome di classe chiamato item.

20
01:35.770 --> 01:43.420
Poi dobbiamo creare quattro campi e
quattro variabili all'interno di questa
classe: nome ID, prezzo e quantità.

21
01:43.450 --> 01:47.680
Ogni variabile rappresenta un'entità, un
campo o una colonna.

22
01:47.680 --> 01:51.580
Quindi è necessario inserire le righe o i
record.

23
01:51.580 --> 01:55.540
Questi record sono istanze della classe
entità.

24
01:55.540 --> 02:03.280
Quindi, ogni volta che dobbiamo inserire
un nuovo record nella tabella del

25
02:03.280 --> 02:06.010
database, dobbiamo creare un'istanza di
questa classe di entità denominata item.

26
02:06.040 --> 02:10.950
Passiamo ad Android Studio e vediamo come
creare la classe entità.

27
02:10.980 --> 02:16.890
All'interno di esso, dobbiamo creare un
nuovo pacchetto chiamato DB della stanza.

28
02:16.890 --> 02:22.830
E all'interno di questo pacchetto creeremo
una nuova classe Kotlin Data.

29
02:22.830 --> 02:25.680
Selezionare la classe Data e denominarla
nodo.

30
02:25.710 --> 02:32.670
Questo nodo fungerà da modello per ogni
nodo inserito nel nostro database.

31
02:32.670 --> 02:36.330
A tal fine, è necessario annotarlo con
un'entità.

32
02:36.360 --> 02:42.150
Per dire ad Android Studio che questa
classe agirà come entità nel database
della nostra stanza,

33
02:42.150 --> 02:48.420
dobbiamo annotarla con l'annotazione add
entity e al suo interno dobbiamo
specificare il nome della tabella.

34
02:48.450 --> 02:49.920
Ecco il nome della tabella.

35
02:49.920 --> 02:52.590
La chiamo tabella delle note.

36
02:52.590 --> 02:53.760
È molto semplice.

37
02:53.790 --> 03:00.990
Qui stiamo dicendo ad Android Studio che
il nodo agirà come un'entità, e un'entità
è

38
03:00.990 --> 03:04.710
una tabella in una stanza e il nome della
tabella sarà come tabella dei nodi.

39
03:04.710 --> 03:12.810
Se non lo si specifica, se si scrive
semplicemente entità Android Studio creerà
una tabella con

40
03:12.810 --> 03:20.470
il nome del nodo come nome della classe,
ma preferisco essere specifico e dire ad
Android

41
03:20.500 --> 03:24.100
Studio che il nome di questa tabella sarà
come tabella dei nodi all'interno del
nodo.

42
03:24.100 --> 03:26.770
Qui occorre specificare i campi.

43
03:26.770 --> 03:33.400
I campi sono i campi entità che
rappresentano le colonne della nostra
tabella.

44
03:33.400 --> 03:41.380
Per prima cosa dobbiamo creare una
variabile di tipo integer denominata id e
inizializzata con zero val.

45
03:41.410 --> 03:42.760
Titolo n.

46
03:42.790 --> 03:46.300
Titolo titolo di tipo stringa val.

47
03:46.330 --> 03:47.380
Descrizione.

48
03:47.380 --> 03:51.640
È di tipo stringa e val color.

49
03:51.640 --> 03:53.440
È di tipo int.

50
03:53.440 --> 04:00.580
Abbiamo quindi creato questa classe
annotata con entity, indicando ad Android
Studio di creare una

51
04:00.610 --> 04:06.610
tabella di nodi denominata nodes table con
quattro colonne ID, titolo, descrizione e
colore.

52
04:06.610 --> 04:11.440
A proposito, il colore è memorizzato come
un intero argb.

53
04:11.440 --> 04:21.330
Qui non posso usare il colore del
gradiente dell'interfaccia utente di
Android x, perché la stanza

54
04:21.330 --> 04:26.430
non supporta direttamente tipi complessi
come il colore, quindi useremo un intero
al posto del colore.

55
04:26.460 --> 04:27.480
Un'ultima cosa.

56
04:27.480 --> 04:28.680
Dobbiamo menzionarlo.

57
04:28.680 --> 04:32.820
Qui possiamo aggiungere l'annotazione di
chiave primaria.

58
04:32.820 --> 04:40.080
È quindi necessario specificare una chiave
primaria per la tabella note, in modo che

59
04:40.080 --> 04:44.550
sia una chiave unica e non si ripeta mai
con autogenerazione uguale a true.

60
04:44.550 --> 04:51.000
Quindi, ogni volta che si crea un nuovo
record della nota, ogni volta

61
04:51.000 --> 04:55.740
che si crea una nuova istanza della nota,
l'ID verrà incrementato di uno.

62
04:55.740 --> 05:00.240
Si tratta quindi di una generazione
automatica e non la specificheremo.

63
05:00.240 --> 05:06.840
Android studio e il database della stanza
generano automaticamente questo

64
05:06.870 --> 05:07.590
ID ogni volta che si crea una nuova nota.

65
05:07.590 --> 05:16.260
Inoltre, possiamo creare una colonna info
con nome uguale, ad esempio, al titolo
della nota.

66
05:16.260 --> 05:24.290
Se non si scrive alcuna annotazione
relativa alle informazioni sulla colonna,
il database delle stanze creerà una

67
05:24.290 --> 05:32.600
colonna con il nome della variabile come
campo, ma se si specificano le
informazioni sulla colonna

68
05:32.600 --> 05:35.480
il database delle stanze creerà un titolo
di nodo che si riferisce a questa
variabile titolo.

69
05:35.480 --> 05:42.350
Così otterremo un nodo id titolo,
descrizione e colore e non titolo.

70
05:42.350 --> 05:44.510
Non avrà alcun titolo.

71
05:44.540 --> 05:53.390
Ok, se si specificano le informazioni
sulla colonna, ma per semplicità
preferisco creare variabili simili

72
05:53.390 --> 06:01.940
ai nomi delle colonne, come nel caso del
sommario, abbiamo creato un nome di

73
06:01.970 --> 06:06.410
tabella chiamato tabella nodi, il nome
della classe dell'entità e abbiamo creato
quattro variabili.

74
06:06.410 --> 06:07.370
Queste variabili.

75
06:07.370 --> 06:15.860
I campi entità rappresentano le colonne
id, titolo, descrizione e colore.

76
06:15.860 --> 06:23.270
Ecco come creare tabelle nel database
della stanza, utilizzando

77
06:23.270 --> 06:24.590
l'annotazione entity e la classe data in
Kotlin.