Bem-vindo de volta.
Por último, mas não menos importante, precisamos falar sobre a ameaça da IU.
Este é o último quebra-cabeça de nossa obra-prima aqui.
Depois disso, estamos muito bem preparados para conectar tudo em nossa thread de interface do usuário do código Java.
Essa é a linha em que toda a ação acontece.
E isso é algo que não sabemos como controlar no momento.
E esse é um problema que descobriremos daqui a pouco.
Por enquanto, vamos dar uma olhada no slide a seguir.
Então, aqui temos nosso incrível jogo.
Esta é a primeira versão do jogo.
E, na primeira versão, projetei a aula de esportes aqui para ter um resultado visual divertido.
Portanto, se você estiver criando um novo chefe, poderemos aplicar alguma ação.
Em seguida, essa postagem aparecerá aqui na tela.
Tudo bem.
A aparência disso é a seguinte.
Portanto, temos muitos tópicos em nosso aplicativo aqui.
Por exemplo, este é realmente importante na documentação gratuita.
Ela é referenciada como thread principal, mas, em relação ao nosso desenvolvimento, podemos conhecê-la como uma thread da interface
do usuário e esta aqui.
Portanto, o thread da interface do usuário é responsável por colocar todos esses objetos na tela.
Fizemos nossa primeira experiência com o thread da interface do usuário em nosso tópico de serviço.
Reconhecemos que não temos permissão para realizar grandes atividades nesse thread, nesse thread da interface do
usuário, porque se esse thread aqui estiver sendo bloqueado, o aplicativo deixará de responder
e será encerrado do sistema.
Portanto, com relação ao nosso tráfego de rede, temos que terceirizar isso do thread da interface do usuário.
Tudo bem.
Portanto, conhecemos essa linha da interface do usuário.
Essa é uma parte muito importante do nosso ecossistema Android aqui.
Portanto, este thread está sendo responsável por exibir todos esses objetos aqui.
Tudo bem.
Agora, se quisermos criar um novo objeto boss em nosso primeiro aplicativo, por exemplo, este aqui, precisaremos
colocá-lo no thread da interface do usuário.
Caso contrário, ele falhará porque as exibições necessárias para colocar esse elemento na tela só estão disponíveis
no thread da interface do usuário.
E, portanto, Frieda também tem essa incrível capacidade de descobrir qual desses fios é a principal ameaça.
E, em seguida, podemos usar essa parte para escolher o thread e colocar nosso código nele.
E isso é absolutamente incrível, pois significa que agora também podemos criar ou interagir com objetos que
são algum tipo de saída visual.
Em nosso smartphone aqui, por exemplo, poderíamos definir o campo de texto ao vivo e este aqui
para ter um texto diferente.
Além disso, este valor, este e este.
Ou podemos interagir com coisas como essa, criando um novo objeto que também está sendo exibido na
tela.
Incrível.
Certo.
Vamos descobrir como podemos fazer isso.
Tudo bem.
Então, agora vamos descobrir como podemos executar essa ação no Frida, porque essa é absolutamente alucinante.
Muito bem, vamos fazer isso.
Mas, primeiro, vamos dar uma olhada nesse aplicativo.
Assim, recuperamos a tela do nosso smartphone.
E ainda não estou falando do Free Da Funk, que também é um aplicativo absolutamente fantástico,
mas agora estamos falando da primeira versão desse aplicativo.
Muito bem, aqui está.
E acho que o único sim é que só podemos interagir com esse jogador e perder alguma vida.
Está bem.
Então, agora temos nossa instância de chefe e, portanto, vamos dar uma olhada no código-fonte primeiro.
Portanto, dentro dos aplicativos livres para funcionar.
Sim, aqui temos esse aplicativo.
Portanto, no aplicativo de comunicação, o hacking é livre para encontrar esse O. Nesse exemplo, ele se chama alien, desculpe
por esse aqui.
Estamos apenas tendo um alienígena.
Não está dentro, chefe.
Muito bem, aqui podemos ver esse alienígena.
Esse construtor aqui está imprimindo esse ícone ou esse gráfico na tela.
Isso significa que, se estivermos criando um alienígena, estaremos interagindo com a saída visual aqui.
Portanto, estamos interagindo com o thread da interface do usuário e, na atividade principal, podemos ver que isso acontece aqui.
Portanto, no método de criação aqui, temos uma referência a este tópico.
Tudo o que estamos colocando aqui tem uma referência a esse thread da interface do usuário e, portanto, podemos simplesmente
criar um novo objeto alienígena aqui.
Agora, vamos tentar criar uma instância desse objeto.
Portanto, estamos criando um novo e vamos ver o que está acontecendo.
Quero dizer, com relação ao construtor aqui, sabemos que tudo o que precisamos fornecer é um valor inteiro.
Isso não é nada demais.
Portanto, vamos descobrir se isso é bom.
Tudo bem?
Está bem.
Para fazer isso, basta abrir nossos resultados no editor de código e criar um novo arquivo.
Estamos selecionando JavaScript.
Agora, vejamos, estamos colocando isso à esquerda e aqui temos o código à direita.
Tudo bem.
Criação de uma nova instância.
Portanto, o que precisamos fazer é o seguinte.
Precisamos fazer algo assim.
Está bem.
Isso significa que precisamos obter a referência da classe e, em seguida, precisamos ter esse novo operador nessa referência de
classe para criar uma nova instância.
Precisamos fornecer um valor inteiro aqui.
Vou encerrar esta questão.
Então, aqui estamos você fornecendo o local inteiro e isso deve funcionar, certo?
Já fizemos isso dezenas de vezes.
Então vamos ver.
Está bem.
Primeiro, precisamos nos conectar à máquina virtual Java.
Nossa função anônima.
Agora, a TV precisa de nossa última referência à classe alienígena.
Portanto, essa é a nossa referência de classe estrangeira e podemos obtê-la com os módulos Java e, em seguida, com o ponto do nome do
pacote.
Isso não é verdade.
Ponto e, em seguida, o nome da classe e o iene.
Tudo bem.
Agora temos nossa referência de classe.
Portanto, essa parte está concluída.
Agora, criamos uma nova instância e uma instância igual.
Portanto, essa é a parte esquerda aqui.
E agora precisamos chamá-lo.
Portanto, referência de classe, ponto, ponto ou novo e, em seguida, nosso valor, a margem.
Vamos pegar uma partida de 300.
Então, com relação à margem, vamos ver.
Deixe-me ampliar isso.
Está bem.
Não tenho certeza.
Qual é o parâmetro de ID aqui?
Quer dizer, acho que sobrou.
É isso mesmo.
E este pode ser o topo.
Portanto, com relação à esquerda e à direita.
Sim, tem que ser assim.
Portanto, este é o nosso layout principal.
Talvez possamos mostrá-lo aqui no EP.
Está bem.
Então, aqui está.
Vamos deixar isso de lado.
Tudo bem.
Estamos tendo aqui nosso objeto e este.
E este agora tem algum layout e podemos ver a margem, acho que o valor três e este aqui é a margem
superior.
Isso significa que teremos uma blusa combinando com o que fornecemos aqui.
Desculpe.
Dessa forma.
Portanto, se você estiver fornecendo uma correspondência de 300, esse objeto moverá os 300 pontos para baixo na tela.
E estes dois.
E este aqui.
E isso precisa ou deve ser feito à esquerda e à direita.
A margem.
Se você não definir um determinado valor, o objeto aqui será centralizado automaticamente.
Sim.
Portanto, este deve ser o código aqui.
Está bem.
Portanto, se você estiver criando um novo agora, a única coisa que podemos alterar é este aqui.
Então, até que ponto, para cima ou para baixo, esse objeto moverá esse objeto recém-criado?
Então, depois disso, deve haver este aqui.
Esse é um círculo perfeito.
Sim.
Esse é o nosso novo objeto alienígena, e essa é a margem.
Tudo bem.
Vamos limpar a tela rapidamente para que você não veja meu desenho vergonhoso.
Tudo bem.
Isso significa que estamos fornecendo uma margem de 300.
Portanto, estamos movendo esse objeto dos 300 pontos superiores para baixo.
Sim, é assim que funciona.
Agora, vamos ver.
Vamos iniciar nosso Freedom Server.
E mais tarde, no horário local.
Muito bem.
Este está em segundo plano, aqui.
E agora vamos abrir um novo.
E vamos nos conectar a esse.
Portanto, o nome do pacote e este aqui também é o identificador do pacote.
Portanto, estamos tendo um funk de Frieda.
Ok, vamos nos conectar a este.
Receio que, quando você estiver fazendo as malas.
Frieda Funke.
Sim.
Não digita com epic OC.
Agora estamos conectados.
E vamos ver se conseguimos criar nosso novo chefe alienígena dessa forma.
Muito bem, vamos fazer isso.
Mantemos isso em primeiro plano e estamos criando um em 3 para 1.
Oh, estamos recebendo uma flecha.
Surpresa.
Vejamos.
Visualização do Android.
Visualizar a implementação.
Somente o loop ligado.
Desculpe, somente a ameaça original que criou uma exibição.
Aqui ele pode tocar em suas vistas.
Tudo bem.
Precisamos entrar no thread principal desse aplicativo e, em seguida, podemos interagir com as exibições nesse thread.
Tudo bem.
Isso é algo que já descobrimos na parte teórica dos slides.
Mas como podemos fazer isso com liberdade?
Portanto, vamos dar uma olhada na documentação.
Portanto, no freedom, Ari, dentro dos documentos, temos essa API JavaScript.
E, para ser sincero, isso agora definitivamente não é fácil de encontrar.
Portanto, recomendo enfaticamente que você leia tudo isso pelo menos uma vez, pois há muita coisa aqui,
se você for se aprofundar na instrumentação em Java.
E sim, quero dizer, a maioria das coisas que já encontramos, mas coisas como essa também podem
ser muito úteis.
Por exemplo, podemos enumerar classes carregadas e coisas do gênero.
Normalmente, não gosto de fazer isso em liberdade.
Gosto de fazer a engenharia reversa de um aplicativo estaticamente aqui, mas isso pode ser útil de alguma forma.
Certo, se rolarmos a tela para baixo, vamos ver se conseguimos encontrar este aqui.
Aqui está.
É.
Ele está diretamente abaixo deste.
Mas, sim, talvez você nem reconheça essa execução e função no tópico principal.
VM Tudo bem.
Portanto, temos uma sessão Java na thread principal e, em seguida, temos nossa função anônima aqui.
Com essa função, podemos executar uma ação que está sendo executada no thread principal.
Tudo bem, absolutamente incrível.
Vamos copiar e colar isso em nosso script.
Está bem.
Portanto, em uma referência de classe, não há interação com a interface do usuário.
Estamos apenas recebendo a referência.
Portanto, é absolutamente seguro ter isso fora dessa função no momento.
Abaixo dessa, copiamos tudo e colamos agora essa função aqui.
Vejamos.
Eu me esqueci disso.
Sim.
É uma função.
Está bem.
Portanto, essa é uma função e, como você sabe, fornece nossa função anônima.
Então, ao comentar isso aqui, você entra na ameaça principal e executa o que está dentro dessa função.
Tudo bem.
Agora precisamos interagir com a principal ameaça.
Portanto, nesta aqui, que está criando uma nova visualização, precisa estar nesta ameaça principal.
Então, levamos este para cá e agora vamos ver se funciona.
Copiamos isso e, em seguida, abrimos nosso terminal gratuito e colamos o arquivo e 3 para 1.
É isso aí.
Incrível.
O deslocamento não é tão grande, então podemos vê-lo.
Acho que é o que está atrás desse objeto aqui.
Portanto, agora podemos ver dois objetos. Se isso não estiver acontecendo com você no momento, basta
atualizar essa visualização colocando-a em segundo plano e reabrindo-a, e a visualização deverá aparecer
aqui.
Portanto, às vezes a visualização não é atualizada automaticamente, mas não tenho 100% de certeza de quando é esse o caso
e quando não é, porque podemos ver que esta aqui está sendo exibida diretamente na tela.
Tudo bem, legal.
Então, talvez possamos alterar um pouco esse valor.
Para 500.
Aqui temos outro.
Agora, vamos colocar isso em um loop for.
Portanto, é incrível ter uma saída visual de todas as nossas instâncias neste momento.
Então, vamos fazer isso aqui.
Estamos criando uma nova sequência para barra igual a zero.
Desculpe, eu igualo zero a menos, digamos, 1000 e aumentamos o IA em 100 porque precisamos aplicar uma margem diferente
aqui.
Caso contrário, não teríamos essa saída visual como a que temos aqui.
Então, vamos colar isso.
E escolhemos aqui esse olho.
Sim.
Portanto, agora estamos criando.
Vamos fazer as contas.
Dez novos objetos.
Vamos copiar isso.
E aí está.
Tudo bem, legal.
Então, isso é absolutamente incrível.
Agora você também pode interagir com todos esses outros elementos.
E, por exemplo, este campo de texto de vidas aqui, este valor, este aqui.
Ou também podemos criar uma saída de texto aqui.
Portanto, essa mensagem de brinde, talvez possamos fazer isso.
Vamos criar uma nova mensagem de brinde que será exibida aqui.
Está bem?
Portanto, vamos dar uma olhada na documentação oficial porque precisamos obter
a referência de classe dessa classe de brinde e, em seguida, precisamos identificar se a mensagem que está sendo criada é de
que tipo é esse método.
Se for um método de instância, precisaremos criar uma nova instância e exibi-la aqui.
E, no caso do método estático, podemos simplesmente usar o nome do método nomeado pela classe.
Então, vamos descobrir isso.
No momento, estamos entrando na documentação oficial, portanto, estamos procurando o Android Developer Toast e
o Toast Overview ou talvez este aqui.
Eu escolhi a segunda.
Está bem.
Para criar a mensagem, precisamos chamar o método, criar o texto e vamos ver se conseguimos encontrá-lo.
Quero dizer, aqui parece que estamos sobrecarregados.
Sim.
Portanto, aqui podemos ver que esse é um método estático.
Incrível.
Não precisamos criar uma nova instância, portanto, podemos simplesmente chamar nosso método main text a na nossa referência
de classe até obtermos uma ID de recurso.
E este aqui tem uma sequência de caracteres.
Está bem.
Portanto, agora sabemos que precisamos sobrecarregar isso, criar texto com isso a partir desse tipo.
Portanto, o segundo parâmetro precisa estar na sequência de caracteres.
Esse é o texto que está sendo exibido.
Está bem.
Então, quero dizer, este aqui agora está realmente aprofundado na programação do Android, mas quero apenas mostrar a você como
podemos interagir com esse thread da interface do usuário.
Não é mais realmente gratuito para ser relacionado.
Agora, esse é mais um desenvolvimento do Android.
No entanto, gostaria de mostrar isso a você.
Então, vamos voltar.
Está bem.
Vamos tomar nota.
E este é o método que queremos chamar.
Tudo bem, faça o texto.
Portanto, agora precisamos fazer isso na thread da interface do usuário.
Então, aqui e também vamos comentar isso um pouco na aula, fazendo referência à aula de brinde.
Deseja exibir algum texto na tela?
Está bem.
E este é o método que queremos chamar.
Achei que queríamos ligar.
E aqui temos essa referência de classe.
Portanto, o que precisamos fazer é obter a referência da nossa classe e pontuar o nome do método.
Este aqui.
E vamos ver os parâmetros.
Tudo bem.
Contexto.
Portanto, este aqui é um pouco infeliz, mas também trataremos dele no contexto.
É um pouco mais complicado.
Você pode pensar nisso como se realmente tivesse em contexto essa mensagem de brinde; a função de texto precisa saber em
que contexto ela precisa ser impressa.
No nosso caso agora, isso significa que, no nosso aplicativo aqui, ele precisa ser impresso na tela, nesta
tela de atividade principal.
E esse é o contexto que precisamos fornecer aqui.
E isso também pode ser obtido com o 3D.
Acho que essa é uma frase de efeito, mas eu realmente quero lhe dar o contexto desta aqui.
Portanto, você encontrará isso muitas vezes em relação ao uso, porque essas exibições têm algum contexto
no qual estão sendo exibidas.
E essa é a principal atividade no momento.
Tudo bem.
Está bem.
Em seguida, temos que mapear a sequência.
Portanto, essa não é a cadeia de caracteres que precisamos obter para a referência da classe para esta, porque esta também
precisa ser fornecida em nosso método e, então, temos uma integração.
Ok, com esse podemos lidar, mas com os demais.
Sim, para ser sincero, é difícil.
No entanto, vamos ver como podemos fazer isso.
Vamos ver primeiro, vamos lidar com esse aqui.
Estamos criando um novo contexto de variável e podemos obtê-lo com o uso do Java.
E aqui temos que fornecer o nome da classe do thread de atividade.
Então, vamos ver se conseguimos encontrar o lugar.
Ou seja, no final, só precisamos ter a primeira parte relacionada à atividade porque, em vez de uma atividade,
podemos usar o thread de atividade.
Então, vamos ver se você dá uma olhada e diz não, desculpe, não é aqui, talvez seja aqui ou aqui que temos
neste aqui.
Vamos dar uma olhada na documentação oficial.
Portanto, dentro da atividade.
Aqui está.
É com um aplicativo para Android.
E depois temos a atividade e também o thread de atividade.
Então, copiamos este.
Bem, agora estamos com este e podemos chamar esses métodos nele.
E isso agora também é código Java.
Então, é assim que você obtém o contexto no código Java, você diz para obter o contexto do aplicativo a partir da atividade
e estamos fazendo exatamente isso aqui agora.
Portanto, dizemos que queremos ter o aplicativo atual e, em seguida, queremos obter o contexto do aplicativo.
Portanto, neste momento, estamos reproduzindo o código Java.
Você pode abrir o Android Studio e escrever isso em seu código Java para buscar o contexto do aplicativo.
Você pode escrever seu próprio aplicativo para buscar o contexto do aplicativo.
E então, sim, estamos simplesmente obtendo essa atividade para ela e, em seguida, estamos executando esses dois
métodos nela.
Tudo bem.
Está bem.
Portanto, agora estamos tendo o contexto.
Vejamos.
E este é necessário como parâmetro aqui.
Esse foi difícil, mas acho que funciona dessa forma.
Está bem.
No próximo, mantivemos essa sequência de caracteres e este, quero dizer, é apenas um texto de saída.
Poderíamos consultar a documentação para obter o tipo exato, mas, para ser sincero, eu apenas o experimentei
aqui.
Então, simplesmente tentamos um texto.
Frida é incrível.
Além disso, o hacking de aplicativos da equipe de interface do usuário também foi incrível.
Não apenas na interface do usuário.
Está bem.
E então temos uma inspiração.
Portanto, temos em nossa mensagem de brinde algo como isto aqui, que seria algo como a duração.
Comprimento, um comprimento longo ou curto.
Sim.
Então, vamos dar uma olhada nisso.
Qual é o valor?
Acho que é apenas zero ou um, mas, mesmo assim, vamos dar uma olhada.
Então, estamos procurando bem, acho que temos isso aqui, mas depois a torrada.
Ainda estamos abertos.
É isso aí.
E vamos jogar por muito tempo.
Sim, desde que o valor um e o tiro sejam zero.
Exatamente.
Tudo bem.
Isso significa que temos que inserir.
E este aqui.
E agora há uma coisa que sempre esqueço sobre isso, e isso é apenas criar essa mensagem.
Mas, para exibi-lo, também precisamos chamar esse método show.
Portanto, ele não mostrou método em algum lugar.
Aqui está.
Constrói um objeto de lançamento vazio.
Você deve ligar para a CTU antes de ligar para o Joe.
Vejamos.
Então, podemos simplesmente chamar esse show de show.
Muito bem, vamos voltar ao assunto.
Então, pensei no show.
Vamos ver se isso funciona.
Por isso, também estou bastante animado, pois estava apenas brincando com isso.
Com campos de texto e coisas do gênero.
Acho que não o criei na mensagem de brinde com o 310.
Agora vamos ver.
Está bem.
Três, dois, um.
Portanto, aqui podemos ver que estamos recebendo um erro.
O tipo de argumento Make Text não corresponde a nenhum deles, o que significa que temos três métodos.
Portanto, três métodos sobrecarregados.
Tipos diferentes.
Talvez um número diferente de argumentos.
Sim.
E nenhum deles é igual ao nosso.
Então, vamos dar uma olhada no passado.
Estamos fazendo isso.
Isso significa que o primeiro é o contexto do parâmetro.
Isso seria correto.
É assim que podemos obter o contexto aqui.
Tudo bem.
Então, estamos tendo essa sequência de caracteres móveis.
Portanto, trata-se de algum tipo de cadeia de caracteres e estamos fornecendo essa cadeia, mas ela não parece ser reconhecida
como uma cadeia.
O último é um número inteiro, então acho que esse também está correto.
Sim, esse deve ser o problema relacionado a isso.
Portanto, vamos fazer isso de uma forma um pouco diferente antes de mergulharmos nessa sequência.
Vamos primeiro tentar criar um novo objeto de cadeia de caracteres e, na verdade, um objeto de cadeia de caracteres
Java e, em seguida, fornecê-lo aqui, porque ele pode ser reconhecido como esse tipo aqui e, em seguida, será executado.
Tudo bem.
Vamos ver como podemos criar uma nova instância de string em Java.
Portanto, vamos dar uma olhada na documentação.
Então, vamos pesquisar a string.
Ok, essa é uma longa sequência.
E vamos ver isso.
Temos no construtor coisas como estas.
É isso aí.
Sim.
Está bem.
Só precisamos fornecer alguns gráficos como valor.
Portanto, isso deve funcionar se você voltar ao início.
E aí está.
Vamos criar uma nova opção de string real.
Esse é o problema relacionado ao JavaScript, e o JavaScript não tem esses tipos.
Portanto, esta é uma string em JavaScript, mas pode não ser reconhecida como uma string em Java.
Às vezes funciona e às vezes não funciona.
E agora estamos tendo outra vez.
Tudo bem.
Então, vamos fazer isso.
Essa cadeia também não tem interação com a interface do usuário.
Portanto, podemos usar esse agendamento no método da thread principal.
Portanto, texto para exibição.
Agora precisamos obter.
Desculpe.
Eu estava um pouco longe demais agora.
Primeiro, precisamos obter a referência da classe.
Referência de classe String em Java, mas use.
OC.
A instância da string.
Esse não é o novo dólar holandês.
E aqui você está tendo a ideia de que esta é uma sequência de banho e espero que funcione.
Caso contrário, teríamos que criar uma sequência curta e depois fornecê-la aqui.
Mas vamos ver se isso funciona.
Caso contrário, ele deve travar a essa altura.
Assim, sabemos que não está funcionando.
Tudo bem.
E agora vamos aplicar essa cadeia de caracteres como parâmetro aqui, porque se eu escrever isso no código Java, também estarei
fornecendo uma cadeia de caracteres e não uma sequência SHA ou qualquer outra coisa.
Ridículo.
Porque se eu escrever isso em Java, também estarei fornecendo uma string como parâmetro.
Não estou usando essa sequência de caracteres de forma alguma.
Muito bem, agora vamos ver se isso funciona.
Vamos copiar isso.
Mantenha o smartphone em primeiro plano.
Recupere isso.
Colamos o arquivo e vamos ver.
Três, dois, um.
Eu digitei errado.
Sim.
Sem setas.
Esse é um bom sinal incrível.
Mais uma vez, esqueci de algo.
Será que consegui?
Sim.
Não tenho certeza do motivo, mas isso acontece com frequência.
Este é apenas a criação de um objeto.
E se você quiser exibir esse objeto, precisaremos chamar esse método de show.
Portanto, se você voltar atrás.
Não na cadeia de caracteres, mas na classe de torradas.
Este não.
Está bem.
Portanto, aqui, com esse método de exibição.
E este fará com que o texto apareça na tela.
Portanto, também temos que chamar esse.
Sei que agora é muito complexo interagir com a interface do usuário porque você precisa ter algum conhecimento
de programação do Android, eu diria.
Eu não seria capaz de fazer isso se não estivesse codificando algumas vezes no Android, e isso é absolutamente perfeito para
você neste momento.
Com relação à liberdade, todas essas etapas estão claras neste documento.
Aprendemos que esse é novo, mas todo o resto está claro.
E, com relação à execução ou ao acionamento dessa função, infelizmente, precisamos
ter um pouco de conhecimento de programação off-line aqui, mas isso também pode
ser uma boa ideia se você realmente quiser entrar no Android Hacking.
Tudo bem.
Está bem.
Agora, vamos também executar esse método.
E agora vamos ver.
E desta vez eu não conto.
Simplesmente ligamos o aparelho.
Incrível.
Funciona.
Portanto, acho que essa também é minha primeira mensagem de brinde aqui.
Não brinquei com as mensagens de brinde.
Na maior parte do tempo, eu apenas interagia com exibições de texto e coisas do gênero.
Portanto, isso também é incrível para mim no momento.
E, sim, com isso, damos uma olhada bem profunda no capô.
Portanto, temos que ser um pouco precisos.
E a string no freedom parece ser diferente em relação à ferramenta, à string e ao JavaScript.
Sabemos disso agora mesmo.
E sim, é assim que podemos interagir com a interface do usuário.
Legal, não é?
Tudo bem.
Esta é a última parte da viagem.
Isso também foi intenso para mim neste momento.
Mas com relação à abordagem free to, quero dizer, podemos entender tudo, mas estamos usando-a
dessa forma.
Queremos chamar um sorry, queremos chamar um método, este aqui.
E temos que fornecer esses parâmetros.
E esses são parâmetros um pouco mais complexos que estamos tendo no contexto.
Portanto, estamos obtendo o contexto do aplicativo.
Estamos tendo uma sequência.
E estamos tendo essa duração.
Isso não era tão complexo.
Está bem.
Portanto, isso é tudo para o alto-falante no momento.
E esse também é o final de nossa jornada de advogado.
Na próxima, escreveremos nosso instrutor.
Então, pegaremos esse aplicativo de planejamento de espaço e executaremos todos os nossos scripts
que usamos até agora e os forneceremos ou incluiremos como um único instrutor.
Portanto, isso será muito divertido.
Em seguida, podemos ativar e desativar determinados recursos e vamos ver até onde podemos ir com isso.
Muito bem.
Tudo bem.
Portanto, estou realmente ansioso para vê-lo no próximo vídeo.