1
00:00:02,110 --> 00:00:07,300
Aby mieć pewność, że wylogujemy się po wygaśnięciu tokena, dodam nową funkcję w naszej

2
00:00:07,300 --> 00:00:08,150
akcji auth,

3
00:00:08,160 --> 00:00:13,270
a więc w folderze akcji w auth. Plik js, dodam tutaj nową funkcję, w

4
00:00:13,270 --> 00:00:20,950
której chcę ustawić licznik czasu, który zasadniczo wygasa po wygaśnięciu tokena. Możemy więc na przykład wywołać ten licznik wylogowania zestawu

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

6
00:00:21,880 --> 00:00:31,410
tam, spodziewam się uzyskać czas wygaśnięcia, i tutaj, możemy użyć starego dobrego limitu czasu, który React Native obsługuje w jego wersji Javascript,

7
00:00:31,410 --> 00:00:38,630
aby ustawić licznik czasu, który wygaśnie po tym czasie i powiedzmy, że jest to wartość w milisekundach,

8
00:00:38,630 --> 00:00:43,280
więc to tylko założenie, które mam i musimy upewnić się, że

9
00:00:43,280 --> 00:00:47,530
przekazujemy dane w milisekundach. Odtąd ta funkcja

10
00:00:47,540 --> 00:00:55,480
będzie tutaj wykonywana po wygaśnięciu tokena i tam jest teraz pytanie, co my tam robimy?

11
00:00:56,060 --> 00:00:57,890
Cóż, w końcu chcę wysłać tutaj

12
00:00:57,900 --> 00:00:58,980
wylogowanie, prawda?

13
00:00:58,980 --> 00:01:05,490
Dlatego ustawiony zegar wylogowania prawdopodobnie nie powinien być normalną funkcją, ale tak naprawdę tutaj będę

14
00:01:06,120 --> 00:01:10,370
miał funkcję, która korzysta z Redux Thunk, więc gdzie mamy

15
00:01:10,590 --> 00:01:16,680
tę funkcję w funkcji, w której ta funkcja wewnętrzna zostaje wysłana jako argument, a

16
00:01:17,400 --> 00:01:20,010
zatem raz to zadanie asynchroniczne zakończone,

17
00:01:20,010 --> 00:01:27,660
po upływie tego czasu możemy wysłać wylogowanie, abyśmy mogli wysłać wynik tego twórcy akcji, która jest tą akcją

18
00:01:27,660 --> 00:01:29,510
na końcu, tak

19
00:01:29,670 --> 00:01:32,890
aby miało to miejsce po zakończeniu timera.

20
00:01:32,910 --> 00:01:38,670
Teraz, kiedy się wylogowujemy, chcę również wyczyścić wszystkie uruchomione timery, ponieważ być może mamy

21
00:01:38,670 --> 00:01:45,760
tutaj automatycznie ustawiony timer, którego jeszcze nie ustawiamy, ale wkrótce to zrobimy, a następnie chcę wyczyścić ten

22
00:01:45,760 --> 00:01:49,110
timer, gdy wylogujemy się ręcznie, aby Nie mam

23
00:01:49,120 --> 00:01:55,670
tego timera, nawet jeśli jest zbędny. Możemy więc dodać nową zmienną, może na

24
00:01:55,670 --> 00:02:02,340
górze pliku, tutaj będę nazywał timer, który jest początkowo niezainicjowany, a następnie tutaj, kiedy ustawimy

25
00:02:02,340 --> 00:02:08,760
timer, ustawię wynik ustawionego limitu czasu na timer lub zapisz wynik tego w liczniku czasu,

26
00:02:08,850 --> 00:02:12,860
który jest wskaźnikiem tego licznika czasu i dodaj nową

27
00:02:12,860 --> 00:02:21,920
funkcję, być może tutaj, wyczyść licznik czasu wylogowania, który jest teraz normalną funkcją, a nie funkcją, która pobiera tę wewnętrzną funkcję

28
00:02:21,950 --> 00:02:29,510
wysyłki, ale normalną funkcją, w której po prostu nazywam wyczyść licznik czasu oczekiwania i timer to zmienna

29
00:02:29,510 --> 00:02:30,800
wskazująca timer.

30
00:02:30,800 --> 00:02:36,080
Chcę tylko sprawdzić, czy timer istnieje, jeśli nie jest niezdefiniowany, a jeśli nie jest niezdefiniowany,

31
00:02:36,080 --> 00:02:41,620
wywołam to, funkcja Clear Timeout to wbudowana funkcja wbudowana w JavaScript, która pozwala pozbyć się tego timera.

32
00:02:41,840 --> 00:02:43,290
Dzięki temu możemy

33
00:02:43,290 --> 00:02:47,770
wyczyścić licznik czasu, jeśli go już nie potrzebujemy, a ja chcę się

34
00:02:47,810 --> 00:02:56,540
go pozbyć za każdym razem, gdy się wylogowujemy, więc za każdym razem, gdy się to zdarzy, wywołam czysty licznik czasu wylogowania i jeszcze jedną

35
00:02:56,540 --> 00:03:00,650
rzecz, którą muszę zrobić, gdy Wylogowuję się, muszę oczyścić pamięć asynchroniczną.

36
00:03:00,650 --> 00:03:09,760
Więc tutaj mogę zadzwonić do pamięci asynchronicznej usunąć dane użytkownika elementu, ponownie używając tego samego identyfikatora, którego użyłem do przechowywania

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

38
00:03:10,540 --> 00:03:12,550
Więc użyłem danych użytkownika tam,

39
00:03:12,550 --> 00:03:18,010
muszę użyć tego samego identyfikatora do ich wyczyszczenia. Teraz usuń element zwraca obietnicę i

40
00:03:18,010 --> 00:03:18,680
moglibyśmy

41
00:03:18,730 --> 00:03:25,080
na to poczekać, w takim przypadku musielibyśmy zwrócić tę wewnętrzną składnię, w której otrzymujemy

42
00:03:25,090 --> 00:03:31,600
wysyłkę i wykonujemy nasze zadanie asynchroniczne, więc przenosimy ten kod tutaj, a następnie tutaj możemy

43
00:03:31,670 --> 00:03:33,380
wysłać to akcja.

44
00:03:33,380 --> 00:03:36,500
Moglibyśmy to wszystko zrobić, jeśli jesteśmy zainteresowani

45
00:03:36,500 --> 00:03:41,970
wynikiem usunięcia przedmiotu, ale tutaj nie jestem zainteresowany, po prostu go zwolnię i nie czekam

46
00:03:42,140 --> 00:03:48,560
na spełnienie tej obietnicy, zamiast tego natychmiast zwracam ten nowy obiekt akcji i ufam, że to się skończy.

47
00:03:48,590 --> 00:03:51,440
Teraz oczywiście możesz to zrestrukturyzować, ale tak to

48
00:03:51,440 --> 00:03:57,380
zrobię, powinno to usunąć dane z naszej lokalnej pamięci. Dzięki temu wylogowanie robi to, mamy

49
00:03:57,380 --> 00:04:03,450
funkcję timera wylogowania, który ustawia timer, który wylogowuje się po wygaśnięciu, teraz musimy tylko upewnić

50
00:04:03,450 --> 00:04:07,920
się, że wyślemy tutaj ten zestaw kreatora akcji wylogowania, że używamy

51
00:04:07,920 --> 00:04:15,510
tego kreatora akcji i Chcę tego użyć podczas uwierzytelniania. Mamy więc tę autentyczną

52
00:04:15,510 --> 00:04:22,630
akcję tu i tam na końcu, muszę wysłać set

53
00:04:22,800 --> 00:04:30,770
timer wylogowania, a także tutaj. Tak więc, teraz użyję teraz tej różnej

54
00:04:30,770 --> 00:04:37,280
składni, w której mamy tę wewnętrzną funkcję, która odbiera wysyłanie, aby tutaj mógł wysyłać

55
00:04:37,760 --> 00:04:42,940
ustawiony licznik wylogowania, aby został tutaj uruchomiony i oczywiście oznacza to

56
00:04:45,740 --> 00:04:51,590
również, że tutaj zamiast zwracać to, my również musimy to wysłać, więc

57
00:04:51,590 --> 00:04:59,970
wysyłamy tutaj dwie akcje, co jest absolutnie w porządku. Ustawiam więc licznik czasu, a następnie wysyłam

58
00:05:00,390 --> 00:05:02,270
akcję uwierzytelnienia.

59
00:05:02,290 --> 00:05:08,890
Teraz, oczywiście, zegar wylogowania musi wiedzieć, jak długo powinien to potrwać, wymagany jest czas

60
00:05:08,890 --> 00:05:17,110
wygaśnięcia i spodziewam się tego, ten czas wygaśnięcia po prostu pomieszać nazwy, jako argument tutaj w uwierzytelnieniu, aby

61
00:05:17,110 --> 00:05:20,920
móc go przesłać tutaj do mojego timera wylogowania.

62
00:05:20,920 --> 00:05:27,400
Oznacza to, że każde miejsce, w którym wysyłamy akcję uwierzytelnienia lub w którym korzystamy z tego twórcy akcji, powinienem

63
00:05:27,400 --> 00:05:33,100
powiedzieć, że każde miejsce, w którym to robimy, nie tylko musi podać identyfikator użytkownika i token, ale

64
00:05:33,280 --> 00:05:35,230
także czas wygaśnięcia i zaczyna się

65
00:05:35,470 --> 00:05:38,580
tutaj Zapisz się. Kiedy się

66
00:05:38,590 --> 00:05:46,800
rejestrujemy, mamy tutaj datę ważności i wysyłamy uwierzytelnienie. Teraz uwierzytelnianie wymaga również czasu

67
00:05:46,800 --> 00:05:47,670
wygaśnięcia.

68
00:05:47,670 --> 00:05:52,440
Dobrą rzeczą jest to, że bardzo łatwo jest ustalić, kiedy to

69
00:05:52,440 --> 00:05:58,730
wygasa, ponieważ mamy go w danych odpowiedzi, mamy to wygasające w polu, które jest oczywiście

70
00:05:58,830 --> 00:06:07,970
ciągiem, więc dzięki parseInt możemy przekonwertować to na liczbę a potem nastąpi to w kilka sekund, uwierzytelnij się i ustaw licznik wylogowania

71
00:06:07,970 --> 00:06:11,480
oczekuj wartości w milisekundach, więc pomnożę to

72
00:06:11,690 --> 00:06:19,540
przez 1000 i oczywiście dodam to również przy logowaniu. Dodam tam również jako trzeci

73
00:06:19,580 --> 00:06:23,890
argument, aby w celu zalogowania się

74
00:06:24,110 --> 00:06:31,490
po wysłaniu tej akcji uwierzytelniającej przekazaliśmy również czas wygaśnięcia, który

75
00:06:31,490 --> 00:06:36,520
otrzymujemy z Firebase. Teraz mamy jeszcze jedno miejsce, w

76
00:06:36,530 --> 00:06:38,660
którym musimy to zrobić, i

77
00:06:38,660 --> 00:06:45,740
to jest ekran startowy, ponieważ tam również wysyłamy uwierzytelnianie i tutaj musimy obliczyć pozostały czas, ponieważ uruchamia się

78
00:06:45,950 --> 00:06:47,410
przy każdym ponownym

79
00:06:47,420 --> 00:06:51,080
uruchomieniu aplikacji, więc tutaj nie wiemy ile czasu zajmie wygaśnięcie

80
00:06:51,080 --> 00:06:53,100
tokena i musimy to obliczyć.

81
00:06:53,150 --> 00:07:02,060
Więc tutaj mogę obliczyć czas wygaśnięcia, biorąc po prostu datę wygaśnięcia, która jest obiektem daty i wywołując czas

82
00:07:02,060 --> 00:07:08,090
get, który daje mi swój znacznik czasu w milisekundach od początku czasu,

83
00:07:08,090 --> 00:07:09,070
i

84
00:07:09,800 --> 00:07:14,940
od tego muszę odjąć bieżący czas uzyskania czasu, więc bieżący

85
00:07:15,020 --> 00:07:18,820
znacznik czasu w milisekundach. Będzie to miało miejsce w

86
00:07:18,830 --> 00:07:19,850
przyszłości, jest

87
00:07:19,850 --> 00:07:24,810
to teraz, więc różnica powinna być liczbą dodatnią, ponieważ sprawdzam, że będzie to w

88
00:07:24,830 --> 00:07:28,280
przyszłości tutaj, więc powinna być liczbą dodatnią w milisekundach.

89
00:07:28,310 --> 00:07:35,060
Teraz czas wygaśnięcia tutaj można przesłać w celu uwierzytelnienia, a dzięki temu powinniśmy również mieć automatyczne

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

91
00:07:37,790 --> 00:07:39,450
Teraz, aby

92
00:07:39,470 --> 00:07:46,440
sprawdzić, czy to działa, przejdźmy do autoryzacji. plik js i faktycznie tam, w ustawionej funkcji timera

93
00:07:46,560 --> 00:07:53,350
wylogowania tymczasowo podzielę czas wygaśnięcia przez 1000, co oznacza, że podzielę milisekundy przez 1000, co zamieni je w

94
00:07:53,370 --> 00:07:54,960
sekundy, a to

95
00:07:54,960 --> 00:07:57,320
oznacza, że powinniśmy natychmiast się wylogować.

96
00:07:59,410 --> 00:08:06,940
Jeśli przeładuję, jestem wylogowany, ale wkrótce zauważysz, że tylko teoretycznie działa. Jeśli zaloguję się ponownie, jestem zalogowany

97
00:08:06,940 --> 00:08:12,830
i teraz, ponieważ podzieliłem wartość przez 1000, powinienem się

98
00:08:12,830 --> 00:08:21,370
wylogować po 3. 6 sekund, ale nie jestem. Mogę się poruszać, ale

99
00:08:22,390 --> 00:08:30,720
jeśli przeładuję, rzeczywiście jestem teraz wylogowany. Więc to tak jakby oczyściło dane, ale nie nawigowało nas z powrotem do

100
00:08:30,720 --> 00:08:31,530
ekranu autoryzacji,

101
00:08:31,920 --> 00:08:37,710
a powodem tego jest to, że nigdy nie instruujemy React Native, aby nawigował nas z powrotem do ekranu

102
00:08:37,740 --> 00:08:39,250
autoryzacji, więc to brakujący element.

103
00:08:39,270 --> 00:08:45,300
Opróżnienie naszego sklepu Redux jest przyjemne, ale w reakcji na tę odprawę musimy

104
00:08:45,300 --> 00:08:52,090
upewnić się, że wróciliśmy do ekranu autoryzacji. Aby mieć pewność, że tak się stanie, potrzebujemy jednego miejsca, które jest

105
00:08:52,090 --> 00:08:59,230
zawsze renderowane, które otacza całą naszą aplikację, w którym możemy słuchać naszego sklepu Redux i dowiedzieć się, kiedy nasz token zostanie zresetowany do zera, aby

106
00:08:59,230 --> 00:09:06,480
w takim przypadku móc wrócić do ekran autoryzacji. To byłaby aplikacja. plik js, ponieważ to wszystko

107
00:09:06,490 --> 00:09:08,100
wszystko otacza, ale

108
00:09:08,110 --> 00:09:14,080
problem jest tam, skonfigurowałem tutaj Redux. Więc Redux w moim sklepie jest dostępny tylko

109
00:09:14,080 --> 00:09:19,960
tutaj, więc w zagnieżdżonych komponentach potomnych i to już jest mój komponent nawigacyjny, do którego nie mam

110
00:09:19,960 --> 00:09:21,000
bezpośredniego dostępu.

111
00:09:21,100 --> 00:09:28,700
Rozwiązaniem jest po prostu owinięcie tego innym komponentem. Stworzę to w folderze nawigacji,

112
00:09:29,090 --> 00:09:33,120
ponieważ nadam mu nazwę kontenera nawigacji.

113
00:09:33,140 --> 00:09:37,690
Teraz jest to normalny komponent React, taki jak ten, w

114
00:09:38,820 --> 00:09:46,650
którym nie potrzebuję niczego z React Native, ale w którym właśnie skonfigurowałem komponent kontenera nawigacyjnego, w którym otrzymuję

115
00:09:46,650 --> 00:09:52,980
rekwizyty i zwracam trochę jsx na końcu i eksportuję to jako domyślny kontener nawigacyjny.

116
00:09:54,380 --> 00:10:02,810
Teraz tam chcę skonfigurować nawigację, więc zaimportuję nawigator sklepu z nawigatora sklepu, który znajduje się w tym

117
00:10:02,810 --> 00:10:06,230
samym folderze i to właśnie tu

118
00:10:06,410 --> 00:10:15,110
wrócę, mój nawigator sklepu tak. Teraz mogę używać mojego kontenera nawigacyjnego tutaj w aplikacji. plik js, więc zamiast

119
00:10:15,110 --> 00:10:24,190
importować tutaj nawigator sklepu, importuję mój kontener nawigacyjny z folderu nawigacyjnego oraz z pliku kontenera

120
00:10:24,230 --> 00:10:29,980
nawigacyjnego i używam tutaj kontenera nawigacyjnego zamiast nawigatora sklepu.

121
00:10:29,990 --> 00:10:34,670
Teraz jest to po prostu opakowanie wokół nawigatora sklepu, ale ponieważ jest ono wewnątrz dostawcy,

122
00:10:34,670 --> 00:10:36,410
mam teraz dostęp do Redux.

123
00:10:36,440 --> 00:10:46,150
Więc tutaj możemy zaimportować selektor użycia z React Redux i użyć go tutaj, aby skorzystać z Redux.

124
00:10:46,190 --> 00:10:54,320
Więc tutaj, w kontenerze nawigacyjnym, mogę po prostu uzyskać dostęp do isAuth, powiedzmy, używając selektora use, który przyjmuje tę funkcję, która daje mi dostęp do stanu Redux, a

125
00:10:55,010 --> 00:11:00,410
następnie mogę uzyskać dostęp do stanu. auth. token, aby uzyskać dostęp

126
00:11:00,410 --> 00:11:06,980
do tokena w moim wycinku stanu uwierzytelnienia i użyć operatora podwójnego uderzenia, aby w zasadzie wymusić, aby było to prawda

127
00:11:06,980 --> 00:11:12,620
lub fałsz, a jeśli nie będziemy mieli tokena, będzie to fałsz, więc w takim przypadku wartość Prawda

128
00:11:12,620 --> 00:11:15,460
będzie fałszywa, jeśli mamy token, to będzie prawda,

129
00:11:15,500 --> 00:11:23,780
więc prawda jest prawdziwa, jeśli mamy token, który wydaje mi się sensowny. Teraz możemy użyć efektu, aby zareagować na zmiany

130
00:11:23,780 --> 00:11:25,060
w tym.

131
00:11:25,160 --> 00:11:29,480
Więc tutaj w użyciu efekt, moja tablica zależności zawiera isAuth, więc

132
00:11:29,480 --> 00:11:37,270
gdy zmienia się isAuth, ta funkcja efektu powinna się uruchomić i dlatego tutaj mogę sprawdzić, czy nie jesteśmy uwierzytelnieni, ponieważ

133
00:11:37,270 --> 00:11:39,630
o to dbam, jeśli isAuth

134
00:11:39,670 --> 00:11:45,910
nie jest prawdą , jeśli to prawda, nie dbam o to, ale jeśli to nieprawda, chcę

135
00:11:45,910 --> 00:11:49,220
przejść do ekranu uwierzytelniania i teraz mamy inny problem.

136
00:11:49,390 --> 00:11:55,930
Nawigator jest tutaj i tylko w komponentach renderowanych za pomocą nawigatora mamy

137
00:11:55,930 --> 00:12:03,220
dostęp do rekwizytów. nawigacja. Nawiguj, ale na szczęście React Navigation daje nam luk ratunkowy. Możemy użyć

138
00:12:03,220 --> 00:12:08,770
referencji, aby uzyskać dostęp do funkcji nawigacji za pomocą tego

139
00:12:08,770 --> 00:12:17,550
komponentu, gdy używamy go w naszym kodzie jsx. Możemy utworzyć taki ref z użyciem ref z użyciem hook ref i

140
00:12:17,610 --> 00:12:20,610
użyj naszego ref nav tutaj, wywołując use ref

141
00:12:21,270 --> 00:12:27,070
w ten sposób i powinieneś być świadomy referencji w React, który jest w zasadzie sposobem

142
00:12:27,070 --> 00:12:34,890
na bezpośredni dostęp do elementu renderujemy w jsx, a teraz możemy dodać właściwość ref do nawigatora sklepu i przypisać to do

143
00:12:34,910 --> 00:12:37,450
ref ref lub na odwrót.

144
00:12:37,470 --> 00:12:43,020
To ustanawia połączenie między stałą ref odniesienia a tym elementem, który ostatecznie jest renderowany tu i

145
00:12:43,020 --> 00:12:49,610
teraz, z tym tutaj w efekcie, możemy wywołać navRef. obecnie, tak działają

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

147
00:12:50,830 --> 00:12:59,660
mają bieżącą wysyłkę właściwości. Wysyłka jest metodą udostępnioną przez nawigatora sklepu lub przez ten kontener aplikacji, który jest w końcu,

148
00:12:59,660 --> 00:13:05,420
ponieważ kontener sklepu to nic innego niż to, co ShopNavigator. js eksportuje, który jest takim składnikiem

149
00:13:05,420 --> 00:13:11,010
kontenera aplikacji i ten składnik ma metodę wysyłki, której możemy użyć do

150
00:13:11,010 --> 00:13:15,110
wysłania akcji nawigacyjnej. W tym celu

151
00:13:15,110 --> 00:13:24,650
musimy teraz zaimportować coś z nawigacji React i że coś jest tu obiektem działań nawigacyjnych, a

152
00:13:24,650 --> 00:13:29,720
tu tutaj, nazywamy NavigationActions. nawiguj, a teraz

153
00:13:29,900 --> 00:13:36,620
pozwala nam to nawigować. Jednak nie w przypadku takiego uwierzytelnienia, ale wymaga

154
00:13:36,620 --> 00:13:41,950
to obiektu jako argumentu, w którym konfigurujesz nazwę trasy, i może to być teraz uwierzytelnianie.

155
00:13:41,960 --> 00:13:47,270
W ten sposób możemy teraz nawigować z wnętrza tego komponentu, nawet jeśli znajduje się on poza nawigatorem.

156
00:13:49,080 --> 00:13:56,610
Tak dzieje się z uwierzytelnianiem, ilekroć nasz stan isAuth zmienia się na nieautoryzowany, oznacza to także, że w

157
00:13:56,610 --> 00:14:03,320
nawigatorze sklepu, w naszym przycisku wylogowania, nie musimy nawigować tutaj, ponieważ jeśli uruchomimy wylogowanie, jeśli uruchomimy

158
00:14:03,340 --> 00:14:08,670
tę akcję , usuwamy token w Redux i dlatego powinno to automatycznie

159
00:14:08,670 --> 00:14:12,390
uruchamiać naszą nawigację dzięki temu kontenerowi nawigacyjnemu, a

160
00:14:12,660 --> 00:14:18,140
zatem teraz, jeśli to zapiszemy, powinniśmy przejść do uwierzytelniania, gdy token jest nieprawidłowy.

161
00:14:18,140 --> 00:14:25,530
Więc teraz, jeśli zaloguję się ponownie po 3. 6 sekund, powinniśmy się wylogować i powinniśmy zobaczyć, że

162
00:14:25,530 --> 00:14:26,800
jesteśmy wylogowani,

163
00:14:26,850 --> 00:14:28,690
tak, to wygląda dobrze.

164
00:14:28,890 --> 00:14:30,780
Spróbujmy tutaj jeszcze

165
00:14:36,990 --> 00:14:45,490
raz, tak, wracając i spróbujmy też wylogować się ręcznie.

166
00:14:45,530 --> 00:14:47,340
Więc jeśli pójdę się zalogować, otwórz to, kliknij wyloguj się, to również działa.

167
00:14:47,410 --> 00:14:50,900
Dzięki temu mamy wbudowaną funkcję automatycznego wylogowania,

168
00:14:50,950 --> 00:14:57,580
teraz wróćmy do pliku akcji auth i usuńmy tutaj ten fałszywy podział, ponieważ zrobiłem to

169
00:14:57,580 --> 00:15:02,020
tylko w celu przetestowania, oczywiście nie chcę ręcznie skracać czasu

170
00:15:02,020 --> 00:15:08,980
ważności , zamiast tego mamy tutaj funkcjonalność, która działa i zapewnia, że bez względu na to,

171
00:15:09,160 --> 00:15:16,210
czy się rejestrujemy, czy logujemy, czy cokolwiek, co robimy, mamy token, który przechowujemy, którego możemy użyć

172
00:15:16,210 --> 00:15:21,660
i upewniamy się, że wylogujemy się również automatycznie, jeśli wygaśnie nasz token.

173
00:15:21,700 --> 00:15:24,010
To jest tutaj ukończona aplikacja.