1
00:00:02,110 --> 00:00:07,300
Um sicherzustellen, dass wir nach Ablauf des Tokens abgemeldet sind, füge ich unserer Authentifizierungsaktion eine

2
00:00:07,300 --> 00:00:08,150
neue Funktion

3
00:00:08,160 --> 00:00:13,270
hinzu, also im Aktionsordner in der Authentifizierung. js Datei, ich werde hier eine neue Funktion hinzufügen,

4
00:00:13,270 --> 00:00:20,950
in der ich einen Timer einstellen möchte, der im Grunde abläuft, wenn das Token abgelaufen ist. So können wir diesen Set-Logout-Timer zum Beispiel aufrufen und dort

5
00:00:21,220 --> 00:00:21,840
erwarte

6
00:00:21,880 --> 00:00:31,410
ich die Ablaufzeit und hier können wir das gute alte Set-Timeout verwenden, das React Native in seiner Javascript-Version unterstützt, um einen Timer einzustellen, der

7
00:00:31,410 --> 00:00:38,630
nach dieser Zeit abläuft und Nehmen wir an, dies ist ein Wert in Millisekunden. Das ist also nur

8
00:00:38,630 --> 00:00:43,280
eine Annahme, die ich habe, und wir müssen sicherstellen, dass wir die

9
00:00:43,280 --> 00:00:47,530
Daten daher in Millisekunden übergeben. Danach wird diese Funktion

10
00:00:47,540 --> 00:00:55,480
hier ausgeführt, sobald der Token abgelaufen ist, und dort stellt sich nun die Frage, was wir dort tun.

11
00:00:56,060 --> 00:00:57,890
Nun, am Ende möchte ich mich

12
00:00:57,900 --> 00:00:58,980
hier abmelden, oder?

13
00:00:58,980 --> 00:01:05,490
Daher sollte der eingestellte Abmelde-Timer wahrscheinlich keine normale Funktion sein, aber tatsächlich werde ich hier eine Funktion

14
00:01:06,120 --> 00:01:10,370
haben, die Redux Thunk nutzt. Wo wir also diese Funktion in

15
00:01:10,590 --> 00:01:16,680
einer Funktion haben, in der diese innere Funktion als Argument versendet wird und daher einmal Wenn

16
00:01:17,400 --> 00:01:20,010
die asynchrone Aufgabe beendet ist, können

17
00:01:20,010 --> 00:01:27,660
wir nach Ablauf dieses Timers die Abmeldung senden, sodass wir das Ergebnis dieses Aktionserstellers, bei dem es sich letztendlich um

18
00:01:27,660 --> 00:01:29,510
diese Aktion handelt, senden

19
00:01:29,670 --> 00:01:32,890
können. Dies geschieht, wenn der Timer abgelaufen ist.

20
00:01:32,910 --> 00:01:38,670
Wenn wir uns jetzt abmelden, möchte ich auch alle laufenden Timer löschen, da wir hier möglicherweise

21
00:01:38,670 --> 00:01:45,760
den automatisch eingestellten Timer haben, den wir noch nicht einstellen, aber wir werden es bald tun. Dann möchte ich diesen

22
00:01:45,760 --> 00:01:49,110
Timer löschen, wenn wir uns manuell abmelden Ich habe

23
00:01:49,120 --> 00:01:55,670
diesen laufenden Timer nicht, obwohl er überflüssig ist. Daher können wir hier oben in der Datei

24
00:01:55,670 --> 00:02:02,340
eine neue Variable hinzufügen, die ich als Timer bezeichne, der anfangs nicht initialisiert ist. Wenn wir

25
00:02:02,340 --> 00:02:08,760
dann einen Timer einstellen, setze ich das Ergebnis der Zeitüberschreitung auf Timer oder speichere das

26
00:02:08,850 --> 00:02:12,860
Ergebnis davon in Timer, der ein Zeiger auf diesen Timer

27
00:02:12,860 --> 00:02:21,920
ist und eine neue Funktion hinzufügt, vielleicht hier, Logout-Timer löschen, der jetzt eine normale Funktion ist, keine Funktion, die diese innere Versandfunktion erhält,

28
00:02:21,950 --> 00:02:29,510
sondern eine normale Funktion, bei der ich einfach Clear-Timeout-Timer und den aufrufe Timer ist die Variable, die auf den

29
00:02:29,510 --> 00:02:30,800
Timer zeigt.

30
00:02:30,800 --> 00:02:36,080
Ich möchte nur überprüfen, ob der Timer vorhanden ist, ob er nicht undefiniert ist und ob er

31
00:02:36,080 --> 00:02:41,620
nicht undefiniert ist. Ich nenne dies: Clear Timeout ist eine in Javascript integrierte Funktion, um diesen Timer loszuwerden.

32
00:02:41,840 --> 00:02:43,290
Damit können wir

33
00:02:43,290 --> 00:02:47,770
den Timer löschen, wenn wir ihn nicht mehr benötigen, und ich möchte ihn

34
00:02:47,810 --> 00:02:56,540
entfernen, wenn wir uns abmelden. Wenn dies hier geschieht, rufe ich den Timer zum Löschen der Abmeldung auf und eine andere Sache, die ich tun

35
00:02:56,540 --> 00:03:00,650
muss, wenn Ich melde mich ab, um meinen asynchronen Speicher zu löschen.

36
00:03:00,650 --> 00:03:09,760
Hier kann ich also den asynchronen Speicher aufrufen, um Benutzerdaten von Elementen zu entfernen, wobei wiederum dieselbe Kennung verwendet wird, die ich zum Speichern der Daten

37
00:03:09,760 --> 00:03:10,470
verwendet habe.

38
00:03:10,540 --> 00:03:12,550
Da ich dort unten Benutzerdaten

39
00:03:12,550 --> 00:03:18,010
verwendet habe, muss ich zum Löschen dieselbe Kennung verwenden. Wenn Sie nun den Artikel entfernen, wird ein

40
00:03:18,010 --> 00:03:18,680
Versprechen

41
00:03:18,730 --> 00:03:25,080
zurückgegeben, und wir könnten darauf warten. In diesem Fall müssten wir die innere Syntax zurückgeben, in der wir den

42
00:03:25,090 --> 00:03:31,600
Versand erhalten, und wir führen unsere asynchrone Aufgabe aus. Daher verschieben wir diesen Code hier hinein und dann können

43
00:03:31,670 --> 00:03:33,380
wir diesen hier versenden Aktion.

44
00:03:33,380 --> 00:03:36,500
Wir könnten das alles tun, wenn wir am Ergebnis des

45
00:03:36,500 --> 00:03:41,970
Entfernens eines Elements interessiert sind, aber hier bin ich nicht interessiert. Ich werde dies einfach abfeuern und nicht darauf

46
00:03:42,140 --> 00:03:48,560
warten, dass dieses Versprechen erfüllt wird. Stattdessen gebe ich dieses neue Aktionsobjekt sofort zurück und ich vertraue darauf, dass dies abgeschlossen wird.

47
00:03:48,590 --> 00:03:51,440
Jetzt können Sie dies natürlich umstrukturieren, aber so werde ich

48
00:03:51,440 --> 00:03:57,380
es tun. Dadurch sollten die Daten aus unserem lokalen Speicher entfernt werden. Damit hat logout dies, wir haben die

49
00:03:57,380 --> 00:04:03,450
Logout-Timer-Funktion, die einen Timer festlegt, der sich abmeldet, sobald dies abläuft. Jetzt müssen wir nur noch sicherstellen, dass

50
00:04:03,450 --> 00:04:07,920
wir diesen Set Logout Timer Action Creator hier versenden, dass wir diesen Action

51
00:04:07,920 --> 00:04:15,510
Creator verwenden und Ich möchte dies verwenden, wenn wir uns authentifizieren. Also haben wir diese

52
00:04:15,510 --> 00:04:22,630
Authentifizierungsaktion hier und da am Ende, ich muss den eingestellten

53
00:04:22,800 --> 00:04:30,770
Abmelde-Timer sowie diesen hier versenden. Dort werde ich nun tatsächlich diese andere Syntax

54
00:04:30,770 --> 00:04:37,280
verwenden, bei der wir diese innere Funktion erhalten haben, die den Versand empfängt, so dass ich

55
00:04:37,760 --> 00:04:42,940
hier den eingestellten Abmelde-Timer versenden kann, damit dies hier ausgelöst wird, und dies

56
00:04:45,740 --> 00:04:51,590
bedeutet natürlich auch, dass wir hier anstatt dies zurückzugeben müssen dies auch versenden, also

57
00:04:51,590 --> 00:04:59,970
versenden wir hier zwei Aktionen, was absolut in Ordnung ist. Also stelle ich meinen Timer ein und sende dann

58
00:05:00,390 --> 00:05:02,270
die Authentifizierungsaktion aus.

59
00:05:02,290 --> 00:05:08,890
Jetzt muss der Abmelde-Timer natürlich wissen, wie lange es dauern sollte, die Ablaufzeit ist erforderlich,

60
00:05:08,890 --> 00:05:17,110
und ich erwarte, dass diese Ablaufzeit nur zum Verwechseln von Namen als Argument hier in authentifizieren angezeigt wird, damit

61
00:05:17,110 --> 00:05:20,920
ich dies hier weiterleiten kann zu meinem Logout-Timer.

62
00:05:20,920 --> 00:05:27,400
Das bedeutet, dass jeder Ort, an dem wir die Authentifizierungsaktion auslösen oder an dem wir

63
00:05:27,400 --> 00:05:33,100
diesen Aktionsersteller verwenden, nicht nur die Benutzer-ID und das Token, sondern auch die Ablaufzeit

64
00:05:33,280 --> 00:05:35,230
angeben muss. Dies beginnt

65
00:05:35,470 --> 00:05:38,580
hier mit Anmelden. Wenn wir uns

66
00:05:38,590 --> 00:05:46,800
anmelden, haben wir hier unser Ablaufdatum und versenden authentifiziert. Jetzt benötigt die Authentifizierung auch die

67
00:05:46,800 --> 00:05:47,670
Ablaufzeit.

68
00:05:47,670 --> 00:05:52,440
Das Gute ist, dass es hier sehr einfach ist herauszufinden, wann dies abläuft,

69
00:05:52,440 --> 00:05:58,730
da wir es in den Antwortdaten haben. Dort läuft es in einem Feld ab, das natürlich eine

70
00:05:58,830 --> 00:06:07,970
Zeichenfolge ist. Mit parseInt können wir dies also in eine Zahl konvertieren und dann wird dies in Sekunden sein, authentifizieren und setzen Logout-Timer erwarten Werte

71
00:06:07,970 --> 00:06:11,480
in Millisekunden, also werde ich dies mit 1000

72
00:06:11,690 --> 00:06:19,540
multiplizieren und ich werde dies natürlich auch beim Login hinzufügen. Dort werde ich dies auch als

73
00:06:19,580 --> 00:06:23,890
drittes Argument hinzufügen, damit wir für die

74
00:06:24,110 --> 00:06:31,490
Anmeldung, wenn wir diese Authentifizierungsaktion auslösen, auch unsere Ablaufzeit weiterleiten, die wir

75
00:06:31,490 --> 00:06:36,520
von Firebase zurückerhalten. Jetzt haben wir noch einen anderen Ort, an

76
00:06:36,530 --> 00:06:38,660
dem wir das tun müssen, und das

77
00:06:38,660 --> 00:06:45,740
ist der Startbildschirm, da wir dort auch die Authentifizierung versenden und hier die verbleibende Zeit berechnen müssen, da dies bei jedem Neustart der

78
00:06:45,950 --> 00:06:47,410
App einsetzt. Hier

79
00:06:47,420 --> 00:06:51,080
wissen wir es also nicht Wie lange dauert es, bis der Token

80
00:06:51,080 --> 00:06:53,100
abläuft, und wir müssen dies berechnen.

81
00:06:53,150 --> 00:07:02,060
Hier kann ich also die Ablaufzeit berechnen, indem ich im Grunde genommen das Ablaufdatum nehme, das ein Datumsobjekt ist, und

82
00:07:02,060 --> 00:07:08,090
get time darauf aufrufe, das mir den Zeitstempel in Millisekunden seit Beginn der

83
00:07:08,090 --> 00:07:09,070
Zeit gibt,

84
00:07:09,800 --> 00:07:14,940
und von dem ich die aktuelle Zeitstempel-Abrufzeit abziehen muss. also der

85
00:07:15,020 --> 00:07:18,820
aktuelle Zeitstempel in Millisekunden. Dies wird in der Zukunft sein,

86
00:07:18,830 --> 00:07:19,850
dies ist jetzt

87
00:07:19,850 --> 00:07:24,810
so, dass der Unterschied eine positive Zahl sein sollte, da ich überprüfe, dass dies hier in der

88
00:07:24,830 --> 00:07:28,280
Zukunft liegt, also sollte dies eine positive Zahl in Millisekunden sein.

89
00:07:28,310 --> 00:07:35,060
Jetzt kann die Ablaufzeit hier zur Authentifizierung weitergeleitet werden. Damit sollten wir uns auch automatisch

90
00:07:35,330 --> 00:07:36,110
abmelden.

91
00:07:37,790 --> 00:07:39,450
Um zu überprüfen,

92
00:07:39,470 --> 00:07:46,440
ob dies funktioniert, gehen wir zur Authentifizierung. js-Datei und tatsächlich dort, in der eingestellten Abmelde-Timer-Funktion, teile ich

93
00:07:46,560 --> 00:07:53,350
die Ablaufzeit vorübergehend durch 1000, was bedeutet, dass ich die Millisekunden durch 1000 teile, was sie in Sekunden umwandelt,

94
00:07:53,370 --> 00:07:54,960
und das bedeutet, dass

95
00:07:54,960 --> 00:07:57,320
wir jetzt sofort abgemeldet werden sollten.

96
00:07:59,410 --> 00:08:06,940
Wenn ich neu lade, bin ich abgemeldet, aber Sie werden bald feststellen, dass es nur theoretisch funktioniert. Wenn ich mich erneut anmelde, bin ich

97
00:08:06,940 --> 00:08:12,830
angemeldet und da ich den Wert durch 1000 geteilt habe, sollte

98
00:08:12,830 --> 00:08:21,370
ich nach 3 abgemeldet sein. 6 Sekunden aber ich bin nicht. Ich kann herum navigieren, aber

99
00:08:22,390 --> 00:08:30,720
wenn ich neu lade, bin ich jetzt tatsächlich abgemeldet. Es hat also die Daten irgendwie bereinigt, aber es hat uns nicht zurück

100
00:08:30,720 --> 00:08:31,530
zum Authentifizierungsbildschirm

101
00:08:31,920 --> 00:08:37,710
navigiert, und der Grund dafür ist, dass wir React Native niemals anweisen, uns zurück zum Authentifizierungsbildschirm zu navigieren. Das

102
00:08:37,740 --> 00:08:39,250
ist also das fehlende Teil.

103
00:08:39,270 --> 00:08:45,300
Das Löschen unseres Redux-Speichers ist nett, aber als Reaktion auf diese Freigabe müssen

104
00:08:45,300 --> 00:08:52,090
wir sicherstellen, dass wir zum Authentifizierungsbildschirm zurückkehren. Um dies sicherzustellen, benötigen wir einen Ort, der immer gerendert wird

105
00:08:52,090 --> 00:08:59,230
und unsere gesamte App umschließt. Dort können wir unseren Redux-Store anhören und herausfinden, wann unser Token auf Null zurückgesetzt wird, damit wir in

106
00:08:59,230 --> 00:09:06,480
diesem Fall zurück zum navigieren können Authentifizierungsbildschirm. Das wäre die App. js Datei, weil das alles einschließt,

107
00:09:06,490 --> 00:09:08,100
aber das Problem

108
00:09:08,110 --> 00:09:14,080
ist da drin. Ich habe Redux hier eingerichtet. Redux in meinem Shop ist also nur innerhalb von

109
00:09:14,080 --> 00:09:19,960
hier verfügbar, also in verschachtelten untergeordneten Komponenten, und das ist bereits meine Navigatorkomponente, auf die ich keinen direkten

110
00:09:19,960 --> 00:09:21,000
Zugriff habe.

111
00:09:21,100 --> 00:09:28,700
Die Lösung besteht darin, dies einfach mit einer anderen Komponente zu umwickeln. Ich werde das im Navigationsordner

112
00:09:29,090 --> 00:09:33,120
erstellen, weil ich es Navigationscontainer nennen werde.

113
00:09:33,140 --> 00:09:37,690
Dies ist eine normale React-Komponente wie diese, bei

114
00:09:38,820 --> 00:09:46,650
der ich nichts von React Native benötige, sondern nur meine Navigationscontainerkomponente einrichte, in der ich Requisiten

115
00:09:46,650 --> 00:09:52,980
erhalte und am Ende etwas jsx zurückgebe und diese als Standardnavigationscontainer exportiere.

116
00:09:54,380 --> 00:10:02,810
Jetzt dort möchte ich meine Navigation einrichten, also importiere ich den Shop-Navigator aus dem Shop-Navigator, der sich im

117
00:10:02,810 --> 00:10:06,230
selben Ordner befindet, und das werde ich

118
00:10:06,410 --> 00:10:15,110
hier zurückgeben, meinen Shop-Navigator so. Jetzt kann ich meinen Navigationscontainer hier in der App verwenden. js-Datei. Anstatt den Shop-Navigator

119
00:10:15,110 --> 00:10:24,190
hier zu importieren, importiere ich meinen Navigationscontainer aus dem Navigationsordner und dem aus der

120
00:10:24,230 --> 00:10:29,980
Navigationscontainer-Datei und verwende hier den Navigationscontainer anstelle des Shop-Navigators.

121
00:10:29,990 --> 00:10:34,670
Jetzt ist dies einfach ein Wrapper um den Shop-Navigator, aber da er sich innerhalb des Anbieters befindet, habe

122
00:10:34,670 --> 00:10:36,410
ich dort jetzt Zugriff auf Redux.

123
00:10:36,440 --> 00:10:46,150
Hier können wir also den Verwendungsselektor aus React Redux importieren und diesen hier verwenden, um auf Redux zuzugreifen.

124
00:10:46,190 --> 00:10:54,320
Hier im Navigationscontainer kann ich einfach auf isAuth zugreifen, indem ich beispielsweise den Use Selector verwende, der diese Funktion übernimmt, mit der ich auf den Redux-Status zugreifen kann, und

125
00:10:55,010 --> 00:11:00,410
dann auf den Status zugreifen kann. auth. Token, um Zugriff auf das

126
00:11:00,410 --> 00:11:06,980
Token in meinem Auth-Status-Slice zu erhalten und den Double-Bang-Operator zu verwenden, um zu erzwingen, dass dies wahr oder falsch ist.

127
00:11:06,980 --> 00:11:12,620
Wenn wir kein Token haben, ist dies falsch, also ist isAuth in diesem Fall falsch, wenn wir

128
00:11:12,620 --> 00:11:15,460
haben Ein Token wird wahr sein, also ist

129
00:11:15,500 --> 00:11:23,780
Wahrheit wahr, wenn wir ein Token haben, das Sinn macht, denke ich. Jetzt können wir den Effekt hier nutzen, um auf Änderungen

130
00:11:23,780 --> 00:11:25,060
zu reagieren.

131
00:11:25,160 --> 00:11:29,480
Wenn hier also ein Effektarray verwendet wird, enthält mein Abhängigkeitsarray isAuth. Wenn sich

132
00:11:29,480 --> 00:11:37,270
also isAuth ändert, sollte diese Effektfunktion ausgeführt werden. Daher kann ich hier überprüfen, ob wir nicht authentifiziert sind, da dies für mich wichtig

133
00:11:37,270 --> 00:11:39,630
ist, wenn isAuth nicht wahr ist

134
00:11:39,670 --> 00:11:45,910
Wenn es wahr ist, ist es mir egal, aber wenn es nicht wahr ist, dann möchte ich zum

135
00:11:45,910 --> 00:11:49,220
Authentifizierungsbildschirm navigieren und jetzt haben wir ein anderes Problem.

136
00:11:49,390 --> 00:11:55,930
Der Navigator ist hier und nur in Komponenten, die mit Hilfe des Navigators gerendert werden, haben

137
00:11:55,930 --> 00:12:03,220
wir Zugriff auf Requisiten. Navigation. Navigieren Sie, aber dankenswerterweise gibt uns die React-Navigation eine Notluke. Wir können eine

138
00:12:03,220 --> 00:12:08,770
Referenz verwenden, um mithilfe dieser Komponente Zugriff auf die Navigationsfunktionen zu

139
00:12:08,770 --> 00:12:17,550
erhalten, wenn wir sie in unserem jsx-Code verwenden. Wir können einen solchen Ref mit use ref mit dem use ref hook erstellen

140
00:12:17,610 --> 00:12:20,610
und wir erstellen hier einfach unseren nav ref, indem

141
00:12:21,270 --> 00:12:27,070
wir use ref wie diesen aufrufen. Sie sollten sich der Referenzen in React bewusst sein, die im Grunde eine

142
00:12:27,070 --> 00:12:34,890
Möglichkeit für Sie sind, direkt auf ein Element zuzugreifen, das Sie haben In jsx rendern und jetzt können wir die ref-Eigenschaft zum Shop-Navigator hinzufügen und

143
00:12:34,910 --> 00:12:37,450
diese der nav ref zuweisen oder umgekehrt.

144
00:12:37,470 --> 00:12:43,020
Dies stellt also eine Verbindung zwischen der nav ref-Konstante und diesem Element her, das am Ende hier und jetzt

145
00:12:43,020 --> 00:12:49,610
mit diesem hier im Effekt gerendert wird, können wir navRef aufrufen. aktuell, so funktionieren

146
00:12:49,630 --> 00:12:50,830
refs,

147
00:12:50,830 --> 00:12:59,660
sie haben einen aktuellen eigenschaftsversand. Der Versand ist eine Methode, die vom Shop-Navigator oder von diesem App-Container zur Verfügung gestellt wird. Dies ist letztendlich

148
00:12:59,660 --> 00:13:05,420
der Fall, da der Shop-Container nichts anderes als der ShopNavigator ist. js exportiert eine solche App-Container-Komponente,

149
00:13:05,420 --> 00:13:11,010
und diese Komponente verfügt über eine Versandmethode, mit der wir eine

150
00:13:11,010 --> 00:13:15,110
Navigationsaktion versenden können. Dafür müssen wir

151
00:13:15,110 --> 00:13:24,650
jetzt etwas aus der React-Navigation importieren und dass hier und hier etwas das Navigationsaktionsobjekt ist, rufen

152
00:13:24,650 --> 00:13:29,720
wir hier NavigationActions auf. navigieren und

153
00:13:29,900 --> 00:13:36,620
jetzt können wir navigieren. Allerdings nicht mit einer solchen Authentifizierung, sondern erfordert ein

154
00:13:36,620 --> 00:13:41,950
Objekt als Argument, in dem Sie den Routennamen einrichten. Dies kann nun eine Authentifizierung sein.

155
00:13:41,960 --> 00:13:47,270
So können wir jetzt innerhalb dieser Komponente navigieren, obwohl sie sich außerhalb des Navigators befindet.

156
00:13:49,080 --> 00:13:56,610
Dies geht also immer dann zur Authentifizierung, wenn sich unser isAuth-Status in "Nicht authentifiziert" ändert. Dies bedeutet übrigens auch,

157
00:13:56,610 --> 00:14:03,320
dass wir im Shop-Navigator auf unserer Abmeldeschaltfläche nicht hier navigieren müssen, da wir diese Aktion auslösen, wenn

158
00:14:03,340 --> 00:14:08,670
wir die Abmeldung auslösen Wenn wir das Token in Redux löschen, sollte dies

159
00:14:08,670 --> 00:14:12,390
dank dieses Navigationscontainers automatisch unsere Navigation auslösen. Wenn

160
00:14:12,660 --> 00:14:18,140
wir das speichern, sollten wir jetzt zu auth navigieren, wenn das Token ungültig ist.

161
00:14:18,140 --> 00:14:25,530
Also jetzt, wenn ich mich wieder anmelde, nach 3. 6 Sekunden sollten wir abgemeldet sein und wir sollten sehen, dass

162
00:14:25,530 --> 00:14:26,800
wir abgemeldet sind,

163
00:14:26,850 --> 00:14:28,690
ja das sieht gut aus.

164
00:14:28,890 --> 00:14:30,780
Versuchen wir es hier noch

165
00:14:36,990 --> 00:14:37,520
einmal,

166
00:14:37,820 --> 00:14:45,490
ja, gehen wir zurück und versuchen wir auch, uns manuell abzumelden. Wenn ich mich anmelde, öffne dies und klicke auf Abmelden.

167
00:14:45,530 --> 00:14:47,340
Dies funktioniert auch weiterhin.

168
00:14:47,410 --> 00:14:50,900
Damit haben wir die integrierte Funktion zum automatischen

169
00:14:50,950 --> 00:14:57,580
Abmelden. Kehren wir nun zur Auth-Aktionsdatei zurück und entfernen diese Dummy-Unterteilung hier, da ich dies nur zum

170
00:14:57,580 --> 00:15:02,020
Testen getan habe. Natürlich möchte ich meine Ablaufzeit nicht manuell verkürzen Stattdessen

171
00:15:02,020 --> 00:15:08,980
haben wir jetzt hier eine Funktion, die funktioniert und sicherstellt, dass wir unabhängig davon, ob wir uns anmelden oder

172
00:15:09,160 --> 00:15:16,210
anmelden oder was auch immer wir tun, ein Token haben, das wir speichern, das wir verwenden können und das

173
00:15:16,210 --> 00:15:21,660
wir Stellen Sie sicher, dass wir auch automatisch abgemeldet werden, wenn unser Token abläuft.

174
00:15:21,700 --> 00:15:24,010
Dies ist die fertige Anwendung hier.