Tudo bem.
Após a instalação do freedom, vamos dar uma olhada em como conectar um método.
Portanto, isso agora está substituindo um método existente na memória, e esse é o poder da liberdade.
Portanto, começamos com o exemplo que também é fornecido na documentação da API.
Mas deixe-me apresentar algumas informações básicas para este aqui.
Portanto, temos nosso aplicativo e esse aplicativo está carregando um monte de código em código Java, por exemplo, estamos
usando algumas strings em nosso aplicativo.
Talvez tenhamos também uma aula adicional.
E o mais importante para este exercício é que agora estamos importando ou usando uma atividade.
Já vimos isso antes.
Esse é apenas um conteúdo de tela e uma atividade tem algum tipo de ciclo de vida.
Portanto, há certos eventos em uma atividade que podem ocorrer.
Por exemplo, se pausarmos um aplicativo, colocaremos esse aplicativo em segundo plano e, em seguida,
o abriremos novamente.
Em seguida, o método on resume está sendo chamado.
Se uma atividade for criada, o método on create estará sendo iniciado.
Esse é o local onde estamos inserindo nosso código o tempo todo.
Portanto, uma atividade tem vários métodos e o que estamos fazendo agora neste exercício é o seguinte.
A atividade está sendo carregada a partir dessa máquina virtual Java e, ao executar o servidor gratuito,
estamos nos conectando a ele com o nosso cliente e estamos substituindo esse método.
Portanto, estamos nos conectando à classe de atividade e, em seguida, substituindo-a por nosso próprio código.
Portanto, estamos manipulando essa classe no primeiro exemplo aqui.
Não estamos fazendo nada de malicioso aqui.
Apenas imprimimos algumas declarações de que esse método foi executado.
Portanto, isso também é uma coisa realmente incrível para acompanhar quais métodos estão sendo capturados.
E é claro que podemos fazer muitas outras coisas aqui.
Mas, primeiro, vamos começar com este exemplo.
Vamos imprimir algum texto se esse método estiver sendo codificado.
Portanto, estamos sobrescrevendo esse método no Java entre máquinas e, toda vez que o método on
resume é chamado, imprimimos um texto no console.
Muito bem.
Está bem.
Portanto, vamos nos aprofundar no assunto.
Está bem.
De volta à VM do Ubuntu.
Vamos primeiro iniciar nossa configuração, nossa configuração não relacionada à conexão man in the middle, nossa configuração relacionada
à liberação do servidor.
Então, vamos verificar se nossa máquina de retorno está funcionando.
Sim.
Portanto, também podemos buscar a tela aqui.
Legal.
Então, precisamos de um novo terminal e vamos para essa máquina virtual.
Precisamos de privilégios de root e vamos para os dados locais temporários.
Agora vamos iniciar nosso servidor gratuito.
E, no meu caso, acho que estou usando uma versão de 32 bits dos servidores gratuitos em execução.
Colocamos isso à direita porque agora está sendo executado no smartphone.
E, se abrirmos um novo terminal, poderemos usar uma parte de dados livre e precisaremos fornecer o parâmetro
dash para ler os processos por meio da conexão ADB e recuperá-los aqui.
Vejamos.
É isso aí.
Está bem.
Agora vamos dar uma olhada em como podemos nos conectar a essa máquina virtual Java e manipular todas
essas classes, métodos, variáveis e coisas do gênero.
Podemos encontrar isso na documentação oficial, o que é muito, muito útil.
Portanto, eu gostaria de seguir este caminho.
Portanto, dentro do ponto livre ponto ponto re e dos documentos.
E, em seguida, no IP do JavaScript.
Agora podemos procurar por java.
Ponto de atuação.
Falaremos sobre isso em breve.
Aqui está.
E é assim que podemos conectar uma atividade.
Então, pegamos esse código e o desmontamos completamente para descobrir o que está acontecendo
aqui.
Portanto, vamos copiar esse código e abrir um novo terminal, o editor de código do Visual Studio, abrir
um novo arquivo e colá-lo.
Agora podemos selecionar a linguagem JavaScript porque esse código é JavaScript.
Por enquanto, gostaria de reescrever um pouco esse código e, em seguida, usaremos isso em
um modelo gráfico e discutiremos cada linha dele.
O que eu gosto de reescrever é o seguinte: não gosto dessa convenção aqui, então excluo essa aqui, porque
o que estamos tendo aqui é uma chamada de função anônima.
Tudo bem?
É exatamente a mesma coisa.
Mas eu gosto de usá-lo aqui dessa forma, porque assim vejo que, ok, temos uma função java para executar e,
como parâmetro, estamos fornecendo agora uma função anônima.
Não se preocupe com isso.
Vamos pegar isso agora na mesa digitalizadora e depois vamos desmontá-la completamente.
Muito bem, vamos lá.
Pessoal, sabem de uma coisa?
Vamos simplesmente executar esse código primeiro, porque acho que assim será um pouco mais fácil acompanhar isso
na mesa digitalizadora.
Tudo bem.
Não entendemos nada nesse código aqui.
Absolutamente perfeito.
Também começamos com o smiley exatamente da mesma forma.
E depois de algumas seções, nos tornamos ninjas absolutamente sorridentes.
O mesmo acontece com a liberdade aqui.
Eu prometo isso a você.
Portanto, vamos simplesmente pegar esse código e ver como podemos executá-lo.
Então vamos ver.
Está bem.
Primeiro, precisamos de um aplicativo que queremos atingir.
Vamos ver o que está instalado aqui.
Podemos usar o aplicativo que você quiser.
Você também pode usar.
Sim.
Aplicativos pré-instalados, como o aplicativo da câmera, a galeria ou coisas assim.
No meu caso, gosto de usar o aplicativo as, porque o layout era bem doentio, certo?
Com certeza.
Está bem.
Portanto, agora temos esse aplicativo em execução.
A primeira coisa que precisamos fazer é obter o identificador de pacote para este, porque
esse é o identificador que a Frieda usa para se conectar a esse processo.
Deixe-me aumentar um pouco o tamanho desse terminal.
E colocamos isso à direita para obter o identificador do pacote, e podemos simplesmente usar liberado como o problema.
E então estamos buscando ou agarrando por um ano.
Aqui está.
Esse é o processo I. D. e este é o identificador do pacote.
Legal.
Então, agora, vamos copiar isso e aumentar um pouco o tamanho.
E agora começamos a nos conectar a esse processo.
Então, como podemos nos conectar a isso?
O comando é bastante simples.
Tudo o que precisamos fazer é dizer ao Frida para usar a conexão ADB e, em seguida, fornecer o identificador
do pacote.
Portanto, o processo que queremos conectar a isso é tudo por enquanto.
Aprenderemos sobre alguns parâmetros adicionais mais adiante.
Mas, por enquanto, isso é tudo o que precisamos fazer para nos conectarmos a esse processo.
Tudo bem.
E agora podemos ver que estamos no terminal livre aqui.
Portanto, isso está em nosso laptop, mas agora está no terminal que pode interagir com o processo.
Aqui.
Podemos ter duas maneiras de executar um script gratuito diretamente neste terminal aqui.
Ou também podemos fornecer esse free to script como algum tipo de parâmetro aqui, para que possamos salvar esse
free the script, por exemplo, este aqui em um arquivo JavaScript, e então podemos dizer ao free para carregar
esse script aqui.
Em seguida, a ação que mencionamos aqui será executada nesse processo.
Tudo bem, talvez não, mas acho que ficará um pouco mais claro se nos aprofundarmos cada vez mais nesse
assunto.
Está bem.
Então, vejamos, copiamos e colamos isso e agora tudo o que precisamos fazer é colá-lo aqui.
Parece absolutamente bagunçado e podemos ver que o free does também fornece alguma inteligência aqui.
Mas esse código deveria estar funcionando imediatamente.
Portanto, se você pressionar Enter agora mesmo.
Muito bem, não recebemos nenhum erro.
Isso é bom.
Então, o que esse código está fazendo no momento?
Vou lhe dar uma breve introdução a ele.
Estamos nos conectando à classe de atividade do aplicativo Android.
Essa é a classe raiz de todas as atividades e, em seguida, estamos nos conectando ao método no currículo.
Vamos dar uma olhada nisso em breve.
Toda vez que esse método está sendo chamado, imprimimos um texto de depuração e este aqui no
terminal.
Portanto, o que estamos fazendo agora é seguir a conexão no método de currículo de cada aplicativo neste
momento do processo.
Portanto, neste aplicativo aqui e, em seguida, estamos substituindo esse método, dizemos para imprimir a seguinte instrução e, se
fizermos isso, o aplicativo depois travará completamente porque essa é agora a nova definição
desse método.
Portanto, depois disso, também estamos chamando o método original de recebimento que esse aplicativo pode carregar
com o código original que está inserido ali.
Sei que é um pouco complexo neste momento, mas acho que se você testar e se aprofundar nesse tópico, ficará cada
vez mais familiarizado com ele.
Tudo bem.
Portanto, vamos simplesmente executar isso.
Já executamos isso, vamos executá-lo.
Podemos acionar isso se chamarmos o método on the resume.
E este aqui, se você der uma olhada no ciclo de vida da atividade e este aqui.
Portanto, estamos agora na documentação oficial do desenvolvedor do Android e isso está no ciclo de vida de
uma atividade.
Se você rolar a tela um pouco para baixo, poderá ver isso perfeitamente aqui.
Portanto, quando a atividade está sendo iniciada, o método on create está sendo capturado.
Já vimos isso muitas vezes.
Isso cria a atividade.
E sim, esse também é o local onde estamos inserindo nosso código.
Então, após a criação, o método on start está sendo chamado e, em seguida, o método on resume está sendo
chamado.
Então, nossa atividade está em andamento.
Esse é o estado em que nos encontramos no momento.
O aplicativo está simplesmente em execução.
Se pudermos acionar o método on post, por exemplo, se colocarmos esse aplicativo em segundo
plano, depois que o método on resume aqui for chamado novamente.
E, em seguida, nosso aplicativo será executado novamente.
Portanto, ele muda para o estado de execução da atividade após a retomada.
Tudo bem.
Portanto, para acionar o método de retomada, tudo o que precisamos fazer é colocar o aplicativo em segundo
plano e abri-lo novamente.
E vamos fazer isso.
Talvez.
Vamos fechar isso aqui à esquerda, temos nosso cliente e agora substituímos esse método
aqui.
Portanto, se você colocar isso em segundo plano, simplesmente entraremos na tela inicial.
Tudo bem.
Até agora, nada aconteceu porque agora chamamos o método on se voltarmos a esse aplicativo.
Portanto, se você estiver abrindo-o novamente, o método RSU será chamado, vejamos.
Aqui está.
Agora temos uma carga útil de mensagem no currículo.
Vamos chamar a implementação original.
Portanto, este é o nosso texto de depuração aqui e, agora, sempre que colocamos o aplicativo em segundo plano,
substituímos o método on resume pelo código a seguir, imprimimos a declaração de depuração e, em seguida,
chamamos o método original mais uma vez, o que explica por que ele é importante.
Descobriremos isso na próxima seção.
Por enquanto, vamos fazer uma rápida introdução à conexão de um método em geral.
Muito bem, aqui estamos de volta à mesa digitalizadora.
E agora vamos descobrir o que essa função aqui faz.
Vamos desmontar cada uma das linhas e tentar descobrir o que cada uma delas faz
no início.
É um pouco confuso.
Com certeza.
Mas você ficará cada vez melhor quanto mais praticar.
Tudo bem.
Então vamos lá.
Começamos com a primeira linha aqui, esta para executar.
Mas a primeira coisa a fazer antes de entrarmos nesse assunto é que eu acho a estrutura um pouco confusa.
Portanto, vamos descobrir onde esses colchetes começam e onde eles terminam, porque parece absolutamente bagunçado,
ainda mais bagunçado do que meus desenhos neste momento.
Portanto, vamos ver, viajar, atuar.
Esta é uma função e temos o colchete de abertura aqui e agora o colchete de fechamento está aqui no final.
Portanto, não temos um corpo funcional lá dentro.
Acabamos de receber essa chamada de função e todo esse material aqui.
E deixe-me desenhar isso rapidamente neste material aqui.
Isso não é parâmetro.
Eu sei.
Com certeza.
Parece estranho.
Temos a função kapton como parâmetro.
Então, sim, parece um pouco bagunçado, mas vamos conseguir passar por isso.
Tudo bem?
Vamos nos livrar dessa.
E agora vamos usar a próxima função, esta aqui.
Portanto, esse é agora o nosso parâmetro.
E aqui temos uma função anônima, e esta termina aqui.
Sim.
Em seguida, dentro dessa função, temos outra função.
Este aqui.
Neste caso.
Isso começa aqui.
E termina aqui.
Está bem.
Então, acho que agora está um pouco mais limpo, mas todas essas funções começam e terminam, certo?
Está bem.
Portanto, agora podemos começar a analisar esse código de função aqui e começar com o primeiro
que Chabot executou.
E podemos ver em relação aos colchetes e esta é apenas a chamada da função.
Portanto, isso não está na definição da função que estamos chamando aqui de função.
Então, vamos escrever isso em Java dot perform.
E, nesse caso, estamos chamando uma função, mas não temos o corpo da função, portanto, não o temos
dessa forma.
Essa não é uma definição de função.
Portanto, não temos esses dois.
Estamos apenas chamando uma função.
Portanto, só temos essa função chamada em relação a esses colchetes.
Portanto, vou me livrar dessa.
Está bem.
E dentro dessa função, agora estamos fornecendo uma função anônima como parâmetro.
Eu sei, é absolutamente louco, mas além do JavaScript neste momento e, sim, é assim que as coisas funcionam
aqui.
Tudo bem.
Agora, o que o Java faz?
Vimos que os recursos estão disponíveis para várias plataformas.
Já vimos que ele está disponível para iOS, para Linux, Windows, Android e talvez mais.
Não tenho certeza sobre isso.
Portanto, temos que informar à liberdade em qual plataforma estamos operando no momento.
Sobre o que a liberdade deve fazer.
Nesse caso, queremos sobrescrever a função Java, essa função Java.
Entraremos nesse assunto em breve, mas ele é armazenado na máquina virtual Java em seu smartphone
Android.
Assim, quando você coloca seu smartphone, todas as classes de código Java são carregadas nessa máquina
virtual Java.
E agora, ao usar o Java para atuar em liberdade, estamos dizendo liberdade.
Anexe a essa máquina virtual Java.
Então, talvez, talvez, vamos desenhar isso aqui.
Portanto, aqui temos o smartphone.
Tudo bem.
E o smartphone agora tem essa JVM, essa máquina virtual Java, e ela está carregando
ou hospedando todas as classes e métodos Java e muito mais.
E agora, se você estiver escrevendo um Java Dot, execute uma liberdade para se conectar a essa máquina virtual Java.
Portanto, agora temos acesso a todas essas classes e métodos aqui, e é exatamente isso que queremos
fazer.
Queremos substituir uma classe que esse aplicativo está usando e toda vez que o aplicativo é aberto.
Portanto, aqui temos nosso aplicativo.
Este está sendo aberto no smartphone.
Ele também está acessando esses arquivos de classe aqui.
Portanto, são esses.
Sim, esse é o código que é carregado por esse aplicativo e, agora, usando o Frieda, podemos nos
conectar a essa máquina virtual Java, essa aqui, e podemos dizer a ela.
Está bem.
Se você quiser substituir esse método, por exemplo, que este aplicativo está usando, e quando o aplicativo
chamar esse método, nós o substituiremos pelo nosso material.
Queremos sim, queremos fazer nessa função.
Tudo bem.
Está bem.
Então, sim, eu anunciei que é um pouco confuso, mas se fizermos isso cada vez mais e continuarmos praticando,
ficará um pouco mais claro para você.
Tudo bem.
Portanto, é isso que o Java Dot Perform está fazendo.
Ele está apenas dizendo ao free para se conectar à máquina virtual Java que temos acesso a essas
classes e métodos Java.
Tudo bem.
Vou limpar isso rapidamente.
Está bem.
Portanto, não o limpei.
Eu o escrevi de forma um pouco mais limpa, pois acho que é útil se tivermos isso no canto superior
esquerdo para voltar a este.
Tudo bem.
Portanto, agora sabemos o que o Travel Dot Perform está fazendo.
Há alguma mágica acontecendo em segundo plano, mas isso simplesmente diz ao free para se conectar à máquina virtual
Java.
Ok, a seguir temos uma função anônima.
Portanto, este é o nosso parâmetro aqui.
Portanto, estamos fornecendo uma função inteira como parâmetro.
Está bem.
Então, na linha seguinte, temos agora a mágica que Frieda está fazendo e todo o conceito de liberdade,
que é incrível.
Portanto, vamos descobrir o que está acontecendo aqui neste caso.
A primeira parte é sim, é a parte normal do JavaScript.
Portanto, esta aqui é apenas uma variável e vamos escrevê-la e constar a atividade.
Está bem.
Estamos em Charleston, Barry.
April, nós podemos.
Podemos dar o nome que quisermos.
Não há nada de especial aqui.
A mágica aqui acontece na segunda parte.
E este aqui.
Mas não use.
Essa é outra chamada de função.
Então, vamos escrever isso.
E o Java não é usado.
OC.
O que o Tramadol faz?
Primeiro, vamos descobrir qual é o parâmetro dessa função.
E esta aqui é a atividade do aplicativo Android.
Isso agora é uma referência de classe.
Portanto, o nome do pacote é Android app e o nome da classe está aqui.
Esse é o nome da classe.
Isso agora está na classe curta e o que todo mundo está fazendo aqui é obter uma referência
dessa classe e atribuí-la a essa variável de atividade.
Portanto, aqui estamos fornecendo o nome da nossa classe.
E este agora está sendo atribuído à atividade.
Se você der uma olhada na parte superior esquerda, ela terá a seguinte aparência.
Portanto, a máquina virtual Java carregou essa classe de atividade durante a inicialização do aplicativo, a inicialização
desse aplicativo.
Portanto, aqui temos uma classe de atividade e essa classe de atividade está sendo referenciada nessa variável de atividade.
Neste aqui.
Isso significa que, se o aplicativo estiver usando uma atividade nesta, por exemplo, porque o aplicativo
está usando uma atividade, esse é o conteúdo da tela aqui.
Estamos realizando uma atividade.
Esse é o conteúdo da tela desse aplicativo que estamos tendo agora
em referência ao conteúdo da tela deste aqui, em nossa variável de atividade.
Portanto, isso é apenas uma referência a essa classe de atividade na máquina virtual Java.
E isso é absolutamente alucinante, pois significa que toda vez que o aplicativo estiver usando uma
atividade aqui, teremos uma referência a essa atividade, de modo que poderemos substituir todas as variáveis
de método de função de atividade aqui.
E é exatamente isso que acontece na linha seguinte.
Portanto, tudo o que essa linha está fazendo é simplesmente inserir uma referência a esse nome de classe
nessa variável activity.
Tudo bem.
Está bem.
E na próxima linha, podemos ver que agora temos o nome da variável activity.
Então, vamos usar o amarelo novamente.
Portanto, estamos tendo atividade.
E então estamos fornecendo um ponto e agora estamos acessando essa classe como fazemos no mundo
Java, o que é incrível.
Portanto, podemos dizer ponto de atividade e agora podemos fornecer o método que queremos substituir.
E, nesse caso, o método tem um nome.
No currículo.
Portanto, estamos informando a atividade.
No currículo.
Esse é agora o método.
E agora podemos contar a implementação.
Portanto, esse é um ponto em que temos uma ideia.
E agora essa é a terceira parte aqui.
E este agora é a implementação de pontos.
Isso significa que agora podemos fornecer uma nova implementação para esse método.
Então, vamos dar uma olhada na parte superior esquerda.
Mais uma vez, essa atividade tem métodos, por exemplo, no início, na retomada, na pausa e assim por diante.
E o que estamos fazendo agora é dizer ao free para se conectar à máquina virtual Java aqui,
pesquisar a classe de atividade e agora obter o método de retomada.
Isso não é um método.
E agora queremos redefinir isso.
Queremos fornecer uma nova função para esse método aqui.
Portanto, queremos substituir esse código neste momento.
Está bem.
Portanto, é isso que estamos fazendo aqui.
Temos nossa atividade, temos nosso próprio currículo.
E agora dizemos que queremos ter uma nova implementação.
e agora podemos fornecer uma
nova função para essa implementação.
Portanto, estamos informando o sinal de igual e agora estamos informando que queremos ter uma nova função
nesta aqui.
Vou escrever isso aqui.
Portanto, queremos fornecer uma nova função e isso substituirá o método existente no currículo com nosso código
agora.
Portanto, estamos substituindo esse trecho de código na máquina virtual Java pelo nosso código neste momento.
E o que estamos fazendo aqui é simplesmente imprimir uma declaração de depuração enviada.
No currículo e assim por diante.
E esse é o ponto importante neste momento.
Então, esta aqui, esta linha.
E esta é simplesmente a impressão de uma declaração de impacto em nossa máquina de ataque, nosso terminal em nossa
máquina de ataque.
Portanto, se você tiver aqui a nossa máquina de ataque, agora simplesmente imprimimos a instrução de depuração aqui e se você
deixar essa função como está agora.
Portanto, se você estiver substituindo a própria função de retomada dessa forma, o aplicativo falhará.
Por quê?
Porque, se você der uma olhada neste aqui, verá que substituímos o que estava escrito nele.
Substituímos o método original neste momento.
Mas o método original serve a um propósito, é claro.
Portanto, há alguns códigos que precisam ser feitos, caso contrário, o aplicativo não funcionará mais.
E se estivermos substituindo esse trecho de código aqui com o nosso código, com o código do sinal,
acho que é esse o nome da cor.
Em seguida, estamos imprimindo nossa declaração de depuração aqui e aqui.
Mas substituímos a função original e, portanto, o código original não está mais sendo chamado.
Portanto, o aplicativo falha e esse é o motivo da próxima linha aqui.
O que estamos fazendo é ter esse operador.
Esse e esse operador aqui.
Este aqui.
Isso.
Este operador.
Essa é agora uma referência ao objeto de atividade original.
Portanto, se eles estiverem ligando para este ponto no currículo aqui e para este ponto no currículo.
Estamos chamando de volta a função original dessa classe aqui.
Portanto, o que a Frieda está fazendo, nós temos o Java para realizar.
Isso significa que, Frieda, por favor, conecte-se a essa máquina virtual Java.
Pronto, agora temos acesso a todos os métodos e classes armazenados ali.
E dizemos à Frieda aqui nesta linha, por favor, obtenha uma referência da classe de atividade nesta e
armazene-a na variável de atividade aqui.
Certo, então estamos usando essa variável de atividade e agora queremos entrar no método on resume porque agora temos
uma referência à atividade de nossas classes de máquina virtual Java, esta aqui, e agora queremos
sobrescrever o método on resume aqui.
E queremos definir uma nova implementação nesse caso.
Agora estamos fornecendo uma nova implementação que está aqui em Colossenses.
Portanto, estamos substituindo o código existente pelo nosso código neste momento.
Mas isso levaria a um problema porque, se não chamarmos o código original depois, o aplicativo
travará porque substituímos o código original necessário existente pelo nosso código e interrompemos o fluxo
do aplicativo nesse ponto.
Portanto, o que estamos fazendo é, depois de chamar o nosso método, chamar o método original na retomada.
Portanto, precisamos chamar esse método original aqui mais uma vez e, então, o aplicativo poderá funcionar corretamente.
Portanto, depois de imprimir nossa declaração de depuração aqui, esta aqui, o aplicativo é chamado
em seu estado original.
Portanto, não é o aplicativo.
A função obtém o código em seu estado original.
Portanto, depois de imprimir a instrução de depuração, estamos chamando essa função mais uma vez.
E este chama o método original no currículo, o que significa que o aplicativo agora está carregando o método original
no currículo e funciona corretamente.
Sei que há muita coisa aí, mas tudo ficará mais claro.
Tenho vários exercícios para você ver a diferença entre não chamar essa função aqui e chamar
essa função e quando precisamos chamar essa função original e quando não precisamos fazer
isso.
Tudo bem.
Portanto, neste momento, é importante que você tenha uma compreensão básica do que a Frieda
está fazendo agora e das coisas que parecem um pouco complexas.
Eles ficarão mais claros se prosseguirmos com esse ponto.
Portanto, você não precisa entender esse exemplo completamente.
Neste momento, tenho um exercício muito bom em que dividimos essas etapas inteiras em partes individuais e fazemos
experiências com isso.
E, ao fazer isso, você terá uma compreensão do que está acontecendo aqui.
Por enquanto, quero apenas apresentar a você a liberdade, como são esses colchetes e scripts
sofisticados e, sim, o que eles fazem e como funcionam basicamente.
Tudo bem.
Portanto, essa foi a introdução à liberdade.
Já vimos essa vida em um exemplo em que colocamos o aplicativo em segundo
plano e, depois de chamá-lo ou abri-lo novamente e este aqui, vimos que nossa declaração de depuração
foi impressa.
Portanto, é dessa forma que podemos nos conectar a um método existente e substituir a funcionalidade desse método.
Está bem.
E no próximo vídeo, começaremos com um exemplo muito bom que está neste aplicativo.
Portanto, se você for uma pessoa como eu, que não teve muita sorte, encontraremos uma maneira de contornar
isso, pelo menos no mundo Android no momento.
Está bem.
Tudo bem.
Se você não entendeu tudo o que está escrito aqui, não há problema algum.
Passaremos por isso várias vezes para que você possa passar diretamente para o próximo vídeo.
E estou ansioso para vê-lo lá.