WEBVTT

1
00:00.680 --> 00:08.840
Até o momento, temos um problema na
atualização da interface do usuário,

2
00:08.840 --> 00:10.130
que é o texto composto e o valor do
contador no logcat.

3
00:10.160 --> 00:15.020
A solução é usar a recomposição no Jetpack
Compose.

4
00:15.020 --> 00:22.610
Recomposição é o processo de atualização
da interface do usuário com base nas
alterações no estado do aplicativo.

5
00:22.640 --> 00:29.270
Diferentemente do desenvolvimento
tradicional do Android, em que as
exibições são atualizadas de forma

6
00:29.270 --> 00:31.310
imperativa, no Jetpack Compose, a
interface do usuário é descrita de forma
declarativa.

7
00:31.310 --> 00:38.690
Isso significa que você define como a
interface do usuário deve ser com base no
estado atual do

8
00:38.690 --> 00:44.030
aplicativo, e o Jetpack Compose lida com a
atualização automática da interface do
usuário quando o estado muda.

9
00:44.030 --> 00:49.040
Quando o estado do seu aplicativo muda,
como aumentar o contador.

10
00:49.070 --> 00:56.930
O Jetpack compose recompõe automaticamente
a interface do usuário, ou seja, eleva as
funções compostas que definem sua

11
00:56.930 --> 01:04.130
interface do usuário e atualiza apenas as
partes da interface do usuário afetadas
pelas alterações de estado.

12
01:04.160 --> 01:09.650
Por exemplo, se o usuário clicar no
contador, precisaremos atualizar esse
texto.

13
01:09.650 --> 01:13.580
Composable Only não atualiza toda a
interface do usuário.

14
01:13.580 --> 01:16.730
E isso é chamado de Recomposição
Inteligente.

15
01:16.730 --> 01:20.510
Quero que você se concentre comigo para
entender a decomposição.

16
01:20.540 --> 01:23.780
A recomposição é acionada por mudanças no
estado.

17
01:23.780 --> 01:30.950
Portanto, nesse código, estamos alterando
o valor, mas não estamos acionando a
recomposição.

18
01:30.950 --> 01:38.450
Por exemplo, quando o valor do objeto de
estado mutável criado com um estado
mutável de alterações, o Jetpack Compose

19
01:38.450 --> 01:47.450
sabe que a interface do usuário precisa
ser atualizada e recompõe as partes
afetadas da interface do usuário de
acordo.

20
01:47.450 --> 01:56.450
Essa abordagem declarativa e reativa
simplifica o desenvolvimento da interface
do usuário, pois você só precisa

21
01:56.450 --> 02:03.470
se concentrar em descrever como a
interface do usuário deve ficar com base
no estado atual,

22
02:03.500 --> 02:05.330
e o Jetpack Compose se encarrega de
atualizar a interface do usuário quando o
estado muda.

23
02:05.330 --> 02:08.210
Então, como fazer isso? Vamos

24
02:08.210 --> 02:12.860
usar a palavra-chave remember aqui.

25
02:12.860 --> 02:19.550
Vou usar o remember e moverei o estado
mutável de dentro dele.

26
02:19.550 --> 02:25.310
Portanto, aqui estamos atualizando a
interface do usuário sem salvar o estado
no clique.

27
02:25.310 --> 02:33.710
Estamos atualizando a interface do
usuário, mas estamos esquecendo a contagem
e,

28
02:33.710 --> 02:36.500
para evitar o esquecimento da contagem,
usaremos uma palavra-chave chamada
remember.

29
02:36.500 --> 02:43.070
Ao fazer a chamada, lembre-se de que você
está dizendo ao Jetpack Compose para

30
02:43.070 --> 02:48.890
armazenar o valor retornado pela função e
lembrá-lo enquanto a função componível
estiver ativa.

31
02:48.920 --> 02:57.560
Isso significa que, mesmo que a função
composta se

32
02:57.560 --> 02:59.090
recomponha, o valor lembrado persistirá e
não será recalculado.

33
02:59.090 --> 03:03.620
E é por isso que estamos ficando em
primeiro lugar em cada clique.

34
03:03.650 --> 03:06.110
O valor inicial é definido como zero.

35
03:06.140 --> 03:10.610
Quando aumentarmos o contador, o contador
aumentará em um.

36
03:10.640 --> 03:17.960
O valor e o valor atual do contador não

37
03:17.960 --> 03:18.890
serão salvos novamente e serão zerados com
outro clique.

38
03:18.890 --> 03:26.150
Ele aumentará em um, e o sistema Android
esquecerá que o

39
03:26.150 --> 03:28.580
valor é um e o redefinirá para zero várias
vezes.

40
03:28.580 --> 03:31.380
A cada clique, ele aumentará em uma
unidade.

41
03:31.410 --> 03:38.340
Defina o valor do contador como um e
redefina-o para zero porque há um valor
padrão para zero.

42
03:38.340 --> 03:45.150
E é por isso que usamos o remember, porque
precisamos lembrar

43
03:45.150 --> 03:47.640
o estado atual e o valor atual da variável
count.

44
03:47.670 --> 03:49.380
Vamos executar nosso aplicativo.

45
03:49.410 --> 03:51.030
Tente aumentar o contador.

46
03:51.030 --> 03:58.290
Você pode ver que a interface do usuário e
o texto composto estão sendo atualizados
para um e o valor do contador é um.

47
03:58.290 --> 03:58.920
Aumentar.

48
03:58.950 --> 04:00.930
Novamente, aumente o contador.

49
04:00.930 --> 04:02.580
E aqui vamos nós.

50
04:02.610 --> 04:05.280
Nosso aplicativo está funcionando bem.

51
04:05.280 --> 04:11.430
O valor do contador é cinco e o texto do
contador composable está exibindo o número
cinco.

52
04:11.430 --> 04:12.630
Aumente-o novamente.

53
04:12.630 --> 04:13.770
E aqui vamos nós.

54
04:13.770 --> 04:19.110
O valor do contador é 14 e o texto está
exibindo 14.

55
04:19.140 --> 04:27.270
Remember é usado para lembrar o valor da
contagem em todas as recomposições da
função de composição do contador.

56
04:27.270 --> 04:34.920
Portanto, mesmo que a função de contador
se recomponha devido a outras alterações
de estado,

57
04:34.920 --> 04:39.210
o valor da contagem persistirá e o texto
do botão refletirá a contagem atual.