1
00:00:02,100 --> 00:00:03,360
Quindi abbiamo ottenuto molto,

2
00:00:03,390 --> 00:00:05,460
siamo in grado di scrivere dati, recuperare dati,

3
00:00:05,460 --> 00:00:08,190
utilizzare il nostro token per oscillare i dati o per identificare

4
00:00:08,190 --> 00:00:10,950
i prodotti e gli ordini per il nostro utente attualmente connesso,

5
00:00:10,950 --> 00:00:12,610
siamo in grado di accedere e così

6
00:00:12,620 --> 00:00:14,280
via e questo è tutto bello.

7
00:00:14,280 --> 00:00:20,130
Una cosa che non stiamo facendo in questo momento è che non stiamo continuando le nostre

8
00:00:20,130 --> 00:00:23,970
sessioni, per così dire. Se ricarico, devo sempre accedere

9
00:00:24,030 --> 00:00:25,230
di nuovo e

10
00:00:25,230 --> 00:00:31,170
non è proprio quello che voglio, sarebbe bello se potessimo accedere automaticamente se disponiamo di un token

11
00:00:31,170 --> 00:00:38,310
valido e per questo dobbiamo fare due cose: dobbiamo memorizzare il token da qualche parte sul dispositivo, non in Redux perché

12
00:00:38,310 --> 00:00:43,110
Redux è in memoria e questo andrà perso ogni volta che l'app si riavvia.

13
00:00:43,110 --> 00:00:45,920
Quindi, per così dire, deve trovarsi da

14
00:00:45,930 --> 00:00:53,480
qualche parte sul disco rigido del dispositivo e, inoltre, dobbiamo controllare tale memoria ogni volta che la nostra app viene avviata, impostare

15
00:00:53,480 --> 00:00:58,080
automaticamente il token in Redux e reindirizzare l'utente se troviamo un token valido lì.

16
00:00:59,160 --> 00:01:05,590
Ora cominciamo con l'archiviazione perché è un primo passo logico. Per archiviare, è necessario

17
00:01:05,590 --> 00:01:10,090
importare qualcosa qui, non nel creatore dell'azione

18
00:01:10,090 --> 00:01:20,810
prodotti, ma in realtà qui nel creatore dell'azione auth, è necessario importare l'archiviazione asincrona da React Native.

19
00:01:21,930 --> 00:01:23,280
Con quello importato,

20
00:01:23,460 --> 00:01:32,130
possiamo usarlo per salvare i dati sul dispositivo, l'archiviazione asincrona è un'API nativa React che alla fine utilizza un archivio di valori chiave

21
00:01:32,130 --> 00:01:38,370
sul dispositivo che è disponibile sia su iOS che su Android dove possiamo archiviare dati che

22
00:01:38,370 --> 00:01:45,150
persistono tra i riavvii delle app, in modo che possiamo utilizzare per salvare i dati che non vanno

23
00:01:45,150 --> 00:01:47,460
persi all'avvio o al riavvio dell'app.

24
00:01:47,460 --> 00:01:52,910
Quindi aggiungerò una nuova funzione, salverò i dati nello spazio di archiviazione o qualcosa del genere e

25
00:01:53,040 --> 00:02:00,100
lì mi aspetto di ottenere il mio token e il mio ID utente, i due pezzi di dati che mi interessano qui

26
00:02:00,140 --> 00:02:08,970
e ora possiamo usare l'archivio asincrono per imposta un elemento che è il modo in cui salvi i dati e quell'elemento che imposti deve essere una stringa ma

27
00:02:08,970 --> 00:02:11,560
prima di tutto devi definire una chiave e

28
00:02:11,580 --> 00:02:14,840
darò un nome ai dati dell'utente, ma dipende da te,

29
00:02:14,850 --> 00:02:19,260
avrai bisogno di quella chiave in seguito per recuperare i tuoi dati e

30
00:02:19,330 --> 00:02:21,170
il secondo valore ora

31
00:02:21,180 --> 00:02:26,310
è una stringa, quindi la stringa che vuoi salvare lì e devi essenzialmente salvare una stringa.

32
00:02:26,440 --> 00:02:27,340
Ora

33
00:02:27,340 --> 00:02:33,990
non è un problema, possiamo usare JSON. stringify per convertire un oggetto Javascript in una stringa e

34
00:02:33,990 --> 00:02:40,200
l'oggetto che voglio convertire è un oggetto che contiene il mio token che ottengo qui come argomento e contiene userId

35
00:02:40,200 --> 00:02:41,740
che ottengo come argomento.

36
00:02:41,790 --> 00:02:48,980
Quindi, alla fine, salviamo questo oggetto come stringa sul dispositivo.

37
00:02:48,990 --> 00:02:54,590
Ora abbiamo solo bisogno di chiamare i dati di salvataggio in memoria ogni volta che abbiamo terminato l'accesso o la registrazione, quindi qui forse dopo aver

38
00:02:54,590 --> 00:03:01,080
inviato il login, possiamo chiamare i dati di salvataggio in memoria e inoltrare resData. idToken

39
00:03:01,140 --> 00:03:08,100
e resData. localId, quindi le stesse cose che usiamo in

40
00:03:08,100 --> 00:03:11,610
Redux e vogliamo sicuramente usarle lì perché Redux è importante

41
00:03:11,850 --> 00:03:18,090
per l'applicazione in esecuzione, ma lo salvo anche sul dispositivo per quando vogliamo caricarlo al riavvio dell'app.

42
00:03:18,140 --> 00:03:22,810
Ora, tuttavia, che da solo non farà il trucco e ovviamente dobbiamo farlo anche al momento

43
00:03:22,820 --> 00:03:28,340
della registrazione, ma che da solo non farà il trucco, avremo bisogno di un'informazione in più qui prima di continuare.

44
00:03:28,430 --> 00:03:35,780
Sai quale? Dobbiamo sapere per quanto tempo il token è valido perché non

45
00:03:36,230 --> 00:03:42,920
devi dimenticare che alla fine scadrà, motivo per cui per l'accesso e la registrazione, ottieni che scade Nella chiave

46
00:03:43,310 --> 00:03:50,510
nella risposta che ti dice in pochi secondi quanto tempo impiega fino al token non è valido e Firebase non lo

47
00:03:50,510 --> 00:03:51,510
accetterà più.

48
00:03:51,650 --> 00:03:57,590
Dobbiamo anche archiviare tali informazioni perché se torniamo in seguito, se riavviamo l'app dopo tre ore, il nostro

49
00:03:57,590 --> 00:04:01,390
token è probabilmente non valido, quindi dobbiamo sapere quando il token

50
00:04:01,460 --> 00:04:04,370
verrà invalidato in modo che quando verifichiamo

51
00:04:04,370 --> 00:04:09,800
che, quando il l'app si riavvia, quando controlliamo se disponiamo di un token, sappiamo se quel

52
00:04:09,800 --> 00:04:16,460
token che potremmo trovare è in realtà ancora rilevante o se non è già valido e abbiamo comunque bisogno di

53
00:04:16,460 --> 00:04:20,120
un nuovo token, nel qual caso non dovremmo accedere automaticamente all'utente.

54
00:04:20,480 --> 00:04:23,360
Quindi voglio memorizzare la data di

55
00:04:23,360 --> 00:04:31,180
scadenza e creerò qui la data di scadenza come costante, un nuovo oggetto data che alla fine dovrebbe

56
00:04:31,180 --> 00:04:35,020
prendere la data corrente e aggiungere l'ora di scadenza.

57
00:04:37,810 --> 00:04:45,790
Ora la nuova data accetta un oggetto data ma con get time, otteniamo il timestamp corrente in millisecondi dall'inizio

58
00:04:45,790 --> 00:04:49,590
del tempo, per così dire, che è nel qui

59
00:04:49,780 --> 00:04:51,200
1970 in Javascript.

60
00:04:51,570 --> 00:04:57,630
Quindi questo è un importo in millisecondi e, a ciò, possiamo aggiungere resData. scade tra.

61
00:04:58,210 --> 00:05:01,720
Questa è una quantità di secondi, quindi dobbiamo

62
00:05:01,720 --> 00:05:06,910
convertirla in millisecondi ed è anche una stringa, quindi dobbiamo convertirla in un numero.

63
00:05:06,910 --> 00:05:16,490
Quindi qui aggiungerò un plus qui o semplicemente analizzerò alternativamente per convertirlo in un numero intero e quindi lo moltiplicherò per

64
00:05:16,490 --> 00:05:23,550
1000 per convertirlo da secondi a millisecondi perché ottenere tempo ci dà anche millisecondi.

65
00:05:23,570 --> 00:05:29,690
Ora ciò che mi dà è un nuovo timestamp in futuro, che è l'ora corrente più

66
00:05:29,690 --> 00:05:35,990
il tempo di scadenza e lo avvolgo in un altro oggetto data per convertirlo da un

67
00:05:36,110 --> 00:05:44,520
enorme numero di millisecondi in un oggetto data timestamp concreto. Questa data di scadenza è ora ciò che dobbiamo anche passare per salvare

68
00:05:44,530 --> 00:05:48,880
i dati nella memoria, quindi qui mi aspetto di ottenere anche la data

69
00:05:48,880 --> 00:05:51,070
di scadenza e dobbiamo racchiuderla qui.

70
00:05:51,400 --> 00:05:55,810
Quindi qui posso nominare questa data di scadenza forse

71
00:05:55,840 --> 00:06:05,830
per mescolare le cose, questa è la mia data di scadenza e lì voglio chiamare questo bel metodo toISOString che possiamo chiamare

72
00:06:05,830 --> 00:06:11,500
su oggetti data perché questo lo convertirà in una stringa in un

73
00:06:11,500 --> 00:06:14,240
formato standard che Voglio salvare

74
00:06:14,400 --> 00:06:18,150
Ora questo è quello che voglio fare anche per l'iscrizione, quindi

75
00:06:18,150 --> 00:06:20,190
questo può essere copiato lì e

76
00:06:20,520 --> 00:06:22,120
questo è quello che

77
00:06:22,170 --> 00:06:26,220
voglio fare anche lì, creare la data di scadenza e salvarla nella memoria.

78
00:06:26,220 --> 00:06:29,220
Ora lo stiamo salvando nello spazio di archiviazione che è

79
00:06:29,670 --> 00:06:35,670
bello, ma ora dobbiamo anche verificarlo quando eseguiamo l'accesso. Un bel modo per farlo è quello di creare

80
00:06:35,670 --> 00:06:41,040
una nuova schermata e in realtà la creerò al di fuori delle mie cartelle esistenti nella cartella

81
00:06:41,040 --> 00:06:47,570
delle schermate ma né nello shop né nell'utente e darò un nome a questa schermata di avvio e puoi nominarla comunque volere.

82
00:06:47,610 --> 00:06:54,240
L'idea è che mostro questa schermata mentre la mia app si sta avviando e sto scoprendo se l'utente è autenticato o

83
00:06:54,240 --> 00:06:55,380
meno e questo

84
00:06:55,380 --> 00:06:56,770
sarà super veloce, è

85
00:06:56,790 --> 00:07:02,350
probabile che non vedremo nemmeno quella schermata all'avvio dell'app. Ora qui, creiamo un componente React

86
00:07:02,370 --> 00:07:06,670
regolare importando reagire da reagire e lì, importa roba da React

87
00:07:06,910 --> 00:07:11,120
Native, per essere precisi ho bisogno di una vista, l'indicatore

88
00:07:11,130 --> 00:07:17,310
di attività per mostrare uno spinner di caricamento mentre l'app si sta avviando e anche

89
00:07:17,310 --> 00:07:23,280
foglio di stile e archiviazione asincrona perché qui voglio anche accedere all'archiviazione asincrona per scoprire

90
00:07:23,280 --> 00:07:26,450
se abbiamo un token valido o meno.

91
00:07:26,460 --> 00:07:33,660
Quindi qui ho il mio componente della schermata di avvio che è un normale componente React e

92
00:07:33,780 --> 00:07:44,570
l'oggetto foglio di stile qui con Stylesheet. creare e alla fine, possiamo esportare questa schermata di avvio in questo modo. Ora nel componente, presenterò semplicemente l'indicatore

93
00:07:44,580 --> 00:07:56,450
di attività qui con una dimensione grande e un colore di Colori. primario e per questo è necessario importare quei

94
00:07:56,450 --> 00:08:05,100
colori, ovviamente, e assegnare anche un po 'di stile alla vista e

95
00:08:05,100 --> 00:08:13,520
prenderò solo gli stili. schermata qui che ora possiamo aggiungere al foglio

96
00:08:13,520 --> 00:08:16,530
di stile e che dovrebbe

97
00:08:16,690 --> 00:08:23,690
essere molto semplice, flessibile, giustificare il centro contenuti e allineare il centro elementi per

98
00:08:23,720 --> 00:08:29,870
alcuni contenuti centrati verticalmente e orizzontalmente. Ora ovviamente le cose veramente importanti accadono sopra

99
00:08:29,870 --> 00:08:33,520
il codice jsx, qui è dove ora dobbiamo controllare l'archiviazione

100
00:08:33,620 --> 00:08:39,820
asincrona per un token valido e posso farlo con l'aiuto dell'effetto use che mi permette di eseguire

101
00:08:39,820 --> 00:08:42,230
un po 'di logica qui quando

102
00:08:42,250 --> 00:08:51,190
questo componente montato e in effetti qui, non avrò bisogno di dipendenze perché qui all'interno dell'effetto d'uso, ora voglio aggiungere una nuova funzione che

103
00:08:51,190 --> 00:08:58,060
chiamerò provare ad iscriversi o provare ad accedere è più adatto e io uso la funzione separata perché qui

104
00:08:58,090 --> 00:09:04,390
voglio usare async wait che posso fare creando quella funzione interiore che ora posso chiamare qui, prova

105
00:09:04,390 --> 00:09:05,310
ad

106
00:09:05,410 --> 00:09:10,840
accedere perché di nuovo, async qui su questa funzione che passi per usare l'effetto non

107
00:09:10,840 --> 00:09:14,020
sarebbe davvero permesso e qui in prova login,

108
00:09:14,170 --> 00:09:21,460
l'obiettivo ora è controllare l'archivio asincrono per un token valido. Quindi ottengo qui i miei dati utente accedendo a

109
00:09:21,520 --> 00:09:23,030
AsyncStorage. getItem

110
00:09:23,240 --> 00:09:28,750
e quindi utilizzare la chiave utilizzata per l'archiviazione.

111
00:09:28,960 --> 00:09:35,950
Quindi nel mio caso si tratta di dati utente ma è necessario utilizzare qualsiasi chiave utilizzata nella propria autenticazione. file js nella cartella actions

112
00:09:35,950 --> 00:09:43,160
per l'archiviazione dei dati con l'archiviazione asincrona. Quindi ho recuperato questo e ora la cosa importante da sapere

113
00:09:43,160 --> 00:09:49,970
qui è che ottenere l'oggetto, come tutti i metodi di archiviazione asincroni, in realtà è asincrono, il che significa che

114
00:09:50,030 --> 00:09:55,520
il nome suggerisce suppongo, il che significa che ottieni una promessa qui, quindi possiamo aspettare questo

115
00:09:55,520 --> 00:09:58,560
e questo ci restituirà i nostri dati utente.

116
00:09:58,570 --> 00:10:05,200
Ora questi sono i dati come una stringa, per convertirli in un pezzo di dati su

117
00:10:05,230 --> 00:10:14,410
cui possiamo lavorare, avrò i miei dati trasformati con JSON. analizza i dati dell'utente e questo analizza una stringa in

118
00:10:14,410 --> 00:10:24,220
formato JSON e li converte in un oggetto o un array Javascript. Ora prima ancora di provarlo, controllerò se i dati dell'utente non sono veri, quindi se

119
00:10:24,220 --> 00:10:24,850
non

120
00:10:24,850 --> 00:10:31,030
sono impostati, se non riusciamo a trovare alcun dato per quella chiave perché allora so che sicuramente non abbiamo

121
00:10:31,030 --> 00:10:31,720
effettuato l'accesso.

122
00:10:31,780 --> 00:10:36,370
Quindi qui voglio tornare e non continuare e fare una cosa

123
00:10:36,370 --> 00:10:43,810
importante, userò la navigazione dei puntelli e navigherò alla schermata di autenticazione perché questa schermata di avvio deve

124
00:10:43,810 --> 00:10:44,770
essere

125
00:10:45,190 --> 00:10:52,960
aggiunta al navigatore, quindi qui possiamo importarla, importare la schermata di avvio dalla cartella delle schermate ovviamente, schermata

126
00:10:54,070 --> 00:10:57,590
di avvio e la aggiungiamo alla principale nel

127
00:10:57,760 --> 00:11:07,190
navigatore qui, quindi dove abbiamo anche auth e shop e lì in cima, aggiungo avvio e punto alla mia schermata di avvio.

128
00:11:07,350 --> 00:11:11,490
Ciò significa che questa è la prima cosa che carico qui.

129
00:11:11,490 --> 00:11:17,010
Ora su questa schermata di avvio, quindi, vado alla schermata di autenticazione se non riusciamo a trovare

130
00:11:17,010 --> 00:11:22,230
un token, quindi grazie allo switch navigator, lascio quella schermata e vado alla schermata di autenticazione

131
00:11:22,230 --> 00:11:28,810
o allo stack di autenticazione perché non trovo un token. Quindi, se superiamo questo controllo, selezioniamo almeno alcuni dati, ma il token

132
00:11:28,810 --> 00:11:29,950
potrebbe non essere valido.

133
00:11:30,370 --> 00:11:39,980
Quindi avremo ovviamente il token, l'utenteId e la data di scadenza che possiamo estrarre dai dati trasformati dopo questa

134
00:11:40,520 --> 00:11:42,770
riga, qui con questo

135
00:11:43,600 --> 00:11:46,860
oggetto che distrugge la sintassi e

136
00:11:46,870 --> 00:11:54,580
questi sono i tre pezzi di dati con i tre stessi identici nomi che conservo qui

137
00:11:54,580 --> 00:11:56,400
nell'autent. file js. Quindi

138
00:11:56,410 --> 00:12:00,700
qui abbiamo un oggetto con un token, userId e

139
00:12:00,700 --> 00:12:03,000
campo data di scadenza, questo

140
00:12:03,010 --> 00:12:08,580
è ciò che memorizziamo nella memoria asincrona, è quello che posso recuperare qui.

141
00:12:08,610 --> 00:12:11,360
Ora dobbiamo verificare se il token è ancora

142
00:12:11,460 --> 00:12:20,670
valido e per questo, posso ricreare la mia data di scadenza utilizzando una nuova data e passando la data di scadenza che in realtà è una stringa in formato

143
00:12:20,670 --> 00:12:23,220
ISO e ora possiamo aggiungere un controllo

144
00:12:23,220 --> 00:12:27,270
if e vedere se data di scadenza, quindi la data in cui il

145
00:12:27,270 --> 00:12:33,660
token diventa non valido, se è inferiore o uguale alla nuova data, che è il timestamp corrente che significa che

146
00:12:33,660 --> 00:12:39,570
la data di scadenza è nel passato e se è nel passato, quindi il nostro token non è valido.

147
00:12:40,320 --> 00:12:45,300
Non è inoltre valido se non riusciamo a trovare un token o anche se non riusciamo

148
00:12:45,360 --> 00:12:51,900
a trovare un ID utente, se una delle tre condizioni è vera, abbiamo un token non valido o un ID

149
00:12:51,900 --> 00:12:54,550
utente non valido o qualcosa del genere.

150
00:12:54,570 --> 00:12:58,700
Quindi in quel caso, voglio anche tornare e,

151
00:12:59,340 --> 00:13:05,640
naturalmente, passare alla schermata di autenticazione. Se lo superiamo se si verifica, abbiamo

152
00:13:05,700 --> 00:13:10,110
un token, abbiamo un ID utente e il token è ancora valido.

153
00:13:10,110 --> 00:13:17,720
Quindi, se ce la fai qui, chiamerò oggetti di scena. navigazione. navigare nello shop per accedere alla schermata

154
00:13:17,720 --> 00:13:21,020
del negozio e anche importante, devo accedere l'utente e per questo,

155
00:13:21,030 --> 00:13:24,230
abbiamo bisogno di una nuova azione perché non voglio inviare una

156
00:13:24,240 --> 00:13:29,900
richiesta ora, voglio solo cambiare alcuni dati in Redux. Quindi aggiungerò un nuovo creatore di azioni

157
00:13:31,550 --> 00:13:44,200
qui, esporterò const autenticando forse che prende il mio userId e il mio token e che quindi viene utilizzato per modificare i miei dati in Redux e per questo, ora aggiungerò

158
00:13:44,200 --> 00:13:45,250
un

159
00:13:45,250 --> 00:13:54,390
nuovo identificatore di azione, eseguo l'autenticazione con una stringa di autenticare qui e utilizzarlo qui come tipo di autenticazione, allegare il mio

160
00:13:55,290 --> 00:14:02,190
userId quale è il mio userId qui e il mio token che è il token che ottengo

161
00:14:02,190 --> 00:14:08,360
come argomento e ora questa azione di autenticazione è ciò che voglio inviare qui nella

162
00:14:08,370 --> 00:14:09,600
schermata di avvio.

163
00:14:10,730 --> 00:14:15,950
Ma prima di farlo, possiamo anche tornare al creatore dell'azione e alla fine

164
00:14:15,950 --> 00:14:22,520
dell'iscrizione, invece di inviare qui la mia azione di iscrizione personalizzata, possiamo anche spedire l'autenticazione ed

165
00:14:22,550 --> 00:14:23,390
eseguirla

166
00:14:23,510 --> 00:14:33,930
qui, questo creatore dell'azione e semplicemente inoltrare resData. localId come userId e resData. identificato come token

167
00:14:33,950 --> 00:14:40,040
e fare lo stesso alla fine dell'accesso.

168
00:14:40,040 --> 00:14:45,400
Quindi ora ho effettivamente combinato questi due flussi perché alla fine accade la stessa cosa,

169
00:14:45,560 --> 00:14:51,350
quindi ora nel riduttore, nel riduttore di autorizzazione, ovviamente invece di controllare il login e l'iscrizione,

170
00:14:51,350 --> 00:14:57,780
possiamo semplicemente importare autenticare e utilizzare questo identificatore qui, sbarazzarsi dell'iscrizione e lo commenterò per viverlo ancora qui

171
00:14:57,800 --> 00:15:00,830
come riferimento perché accade la stessa cosa.

172
00:15:00,860 --> 00:15:05,980
Quindi ora combinarlo ha senso perché ne abbiamo bisogno anche per questo login automatico.

173
00:15:06,020 --> 00:15:11,090
Quindi qui lo spedisco anche qui per il login manuale e la registrazione manuale

174
00:15:11,090 --> 00:15:17,150
e ovviamente ora con quello, se vuoi, puoi anche sbarazzarti del login e iscriverti qui, di questi

175
00:15:17,150 --> 00:15:20,200
due identificatori perché non lo facciamo usali più.

176
00:15:20,390 --> 00:15:24,380
Ma con ciò, tornando alla schermata di avvio, qui

177
00:15:24,600 --> 00:15:34,480
ora possiamo anche spedire questo e per questo devi solo importare utilizzare l'invio da React Redux e importare l'azione, quindi importa tutto come azioni

178
00:15:34,490 --> 00:15:41,650
di autenticazione forse dalla cartella del negozio, dal cartella delle azioni e dal file auth lì e poi

179
00:15:41,650 --> 00:15:43,190
qui all'inizio, accedi

180
00:15:43,270 --> 00:15:49,590
alla funzione di invio chiamando usa dispatch e con quello disponibile, qui possiamo aggiungere l'invio come

181
00:15:49,800 --> 00:15:55,230
dipendenza ma questo non cambierà mai, quindi l'effetto non verrà mai più eseguito

182
00:15:55,240 --> 00:16:01,330
e qui dopo essere passato al negozio, ora voglio anche inviare le azioni di autenticazione

183
00:16:01,450 --> 00:16:10,510
per autenticare e inoltrare l'ID utente estratto, quindi questo campo qui e il token estratto, quindi questo campo che ho ottenuto dalla

184
00:16:10,510 --> 00:16:19,150
mia memoria asincrona e che ora dovrebbe accedere automaticamente . È stato un sacco di lavoro,

185
00:16:19,150 --> 00:16:24,310
vediamo se funziona. Se lo ricarico, finisco qui nella schermata di accesso perché

186
00:16:24,340 --> 00:16:27,010
in questo momento non ho token validi memorizzati nella memoria asincrona.

187
00:16:27,880 --> 00:16:37,510
Quindi ora se provo ad accedere qui, sono inoltrato, se ora ricarico, finisco di nuovo qui ed è fantastico perché

188
00:16:37,510 --> 00:16:43,560
ora questo significa che questo sembra funzionare e quel token è archiviato.

189
00:16:43,730 --> 00:16:48,230
Ora, ovviamente, sarebbe bello se potessimo disconnetterci anche perché in questo momento, non c'è modo

190
00:16:48,230 --> 00:16:49,070
di farlo.