Muito bem, pessoal, bem-vindos de volta.
Esse desafio foi diferente dos que enfrentamos até agora, porque agora você tem várias
opções, coisas que aprendeu no passado.
Portanto, não se tratava de um tópico especial.
Foi relacionado ao que aprendemos até agora.
Isso torna tudo mais difícil, é claro.
E, caso você tenha tido um pouco de dificuldade, não se preocupe muito com isso.
Vamos dar uma olhada juntos nisso agora e depois.
Tenho certeza de que você entendeu toda a função do aplicativo e como pode corrigi-lo na próxima
vez por conta própria, caso, é claro, tenha conseguido corrigi-lo com sucesso, parabéns.
Esse é um exemplo de aplicativo do mundo real e já encontrei isso muitas vezes em seus aplicativos relacionados
a diferentes tipos de clientes.
Portanto, você conseguiu contornar uma detecção de decisão do mundo real, o que é realmente incrível.
Portanto, seja qual for o caso que temos agora, vamos dar uma olhada nisso juntos.
Portanto, ainda estou com ele aberto aqui.
Vamos pegar esse aplicativo, fazer downloads e verificar a rota e colocá-lo em um novo diretório de aplicativos.
Tudo bem.
Então, vamos dar uma olhada primeiro com.
Bem, aqui temos a atividade principal.
Vejamos, temos algumas coisas do Android, exibição de texto e botão.
Temos uma declaração if aqui.
O utilitário Root é um dispositivo com root.
Isso parece muito promissor.
Então temos algumas coisas.
O dispositivo está enraizado, portanto, sabemos que, com relação ao texto, este é o nosso estado, sim, este
é o estado que não queremos ter, queremos ter este aqui, porque aqui retornaremos desse método, dessa
função.
Portanto, deixamos esse aplicativo.
Está bem.
Agora sabemos com o que estamos lidando em relação a este aqui.
Vamos ver se já podemos corrigir isso sem dar uma olhada na detecção de roteamento.
Pego minha mesa digitalizadora e conversamos sobre isso.
Está bem.
E vamos lá.
Muito bem, aqui estamos nós, de volta.
Vamos dar uma olhada nisso.
Tudo bem.
Essa é a nossa declaração if nessa linha.
Portanto, se entrarmos nessa função, teremos muitas instruções, mas aqui deixaremos essa função.
Portanto, essa é a nossa saída.
Sair.
E não queremos entrar nesse assunto.
Então, vamos recapitular rapidamente o que aprendemos nos últimos vídeos.
E digamos que nos livremos dessa instrução aqui.
Nós corrigimos isso ou excluímos essa declaração se.
Como isso nos leva a algo mais, vamos dar uma olhada.
Então, digamos que esse não exista mais.
Ok, então temos uma instrução regular.
Outro.
Mas, a essa altura, ainda estamos indo embora.
Portanto, isso não nos traz muito resultado até que também excluamos a instrução return aqui.
Se excluirmos essa, teremos outra instrução adicional.
Este aqui.
Este e este.
Sim.
Isso está faltando.
Tudo bem.
Isso significa que temos um dispositivo que mostra que ele tem acesso root.
Mas também temos um dispositivo que diz: "Ah, está tudo bem".
Portanto, com esses dois estados, conseguimos realizar nossas tarefas.
Mas, na minha opinião, essa não é uma solução realmente limpa porque, se não corrigirmos isso, se a instrução aqui,
esta aqui, e simplesmente a excluirmos, o dispositivo ainda será sinalizado como tendo sido enraizado.
E isso significa que, sim, alguns recursos podem não ser possíveis de usar neste aplicativo.
É claro que, nessa atividade, não há problema, mas talvez em relação a outros serviços possamos encontrar alguns
problemas.
Portanto, essa é uma boa abordagem, mas não a solução.
Se quiser, você também pode tentar fazer isso.
Sim.
Livre-se da instrução return e também da instrução if e veja como fica.
Mas agora chegarei à solução real.
Está bem.
Então, deixe-me limpar a tela rapidamente.
Tudo bem.
E agora vamos dar uma olhada nisso.
Portanto, essa é a nossa detecção de roteamento.
Vamos ver como isso funciona.
Eu clico na classe e lá vamos nós.
Portanto, antes de mais nada, quero agradecer e mencionar o autor deste artigo.
Vou, sim, misturá-lo agora mesmo.
Portanto, essa detecção de enraizamento está funcionando absolutamente bem.
Não há nenhum problema com essa detecção de enraizamento.
Ele protege o usuário contra a execução de um aplicativo em um smartphone modificado.
Mas, ainda assim, como invasor, precisamos corrigir isso.
Então, vamos dar uma olhada em como isso funciona e como podemos contornar esse problema.
Está bem.
A primeira parece bastante promissora, então pego minha caneta de volta.
Aqui está.
O primeiro método é o enraizamento do dispositivo.
E vamos dar uma olhada na função em si.
Não temos nenhum parâmetro aqui, e retornamos um valor booleano nesse caso.
Ok, isso é muito interessante.
Vamos ver como fica internamente.
Então, vamos limpar isso.
Então, retornamos esse método ou o valor desse método ou o valor desse método.
Ops.
Ou este método.
Aqui está.
Então, esse sinal significa uma instrução OR.
O que uma declaração or faz?
E vejamos, temos a seguinte tabela binária.
Portanto, temos A e B, sendo que este é 0101 e A é 0011.
Portanto, se os combinarmos com um OR, obteremos o seguinte resultado.
Zero e zero será zero.
Com relação à melodia ou declaração, zero um será um, um e zero também será um e um.
E um será também um.
Isso significa que, se uma condição for definida como um, o resultado será um.
Caso contrário, se ambos forem negativos ou falsos, a saída será zero.
Tudo bem.
Com relação à nossa detecção de roteamento, isso significa que se um deles retornar verdadeiro, então toda a função
aqui se tornará verdadeira.
Portanto, esse valor booleano aqui se tornará verdadeiro.
Isso é muito bom para a detecção de roteamento, pois vamos dar uma olhada nisso.
Por exemplo, o primeiro método de verificação Method one check method one checks.
Se tivermos chaves de teste ativadas em uma tag de compilação.
Ok, o que quer que isso signifique.
Se tivermos aqui uma declaração verdadeira, não precisaremos entrar aqui e aqui para sinalizar esse dispositivo como
sendo roteado, pois uma declaração verdadeira aqui é suficiente para fazer com que toda a saída seja roteada.
Isso significa que, se a função aqui retornar um, obteremos true, o que significa que o dispositivo está roteado.
Se essa função retornar um zero, o que significa falso, o dispositivo não está sendo roteado.
Está bem.
Então vamos ver.
Como podemos obter um zero?
E uma declaração falsa.
Bem, temos que usar os três métodos.
Portanto, nesse caso, também temos um método C e esse método C também precisa ser zero.
Está bem.
Então, deixe-me limpar isso rapidamente e depois entraremos em detalhes sobre as funções.
Tudo bem.
Portanto, temos três métodos.
Cada um deles retorna um valor.
E se um desses valores for verdadeiro, perderemos.
Digamos que eu perca, porque não é sua culpa se eu não contornar isso.
Está bem.
Tudo bem.
Vamos dar uma olhada no primeiro método.
O primeiro método verifica se temos algum texto de compilação com as chaves de teste ativadas.
Portanto, se esse for o caso, estamos retornando.
Verdadeiro.
Caso contrário, retornaremos falso.
Está bem.
Próximo.
Temos este aqui.
Check Method two, this e this Verifica se determinados aplicativos estão sendo instalados, por exemplo,
o superusuário.
O binário.
E as outras coisas.
Se um deles estiver instalado, o dispositivo, o caminho existir, ele retornará.
Verdadeiro.
Portanto, perdemos.
Ou digamos que eu perca.
E se for falso, nós ganhamos.
O que significa Nenhum desses binários ou apks foi identificado no sistema.
Por último, mas não menos importante, temos o método de raiz de verificação três e os loops de verificação.
E esse método executa um comando do sistema, o que significa que estamos verificando se o binário existe no
sistema.
Portanto, essas são nossas três detecções de enraizamento.
E se uma delas for verdadeira, todo o dispositivo será sinalizado como enraizado.
Está bem.
Portanto, uma abordagem seria aplicar todos esses três métodos aqui.
Portanto, em vez de retornar true, podemos entrar aqui e retornar false, mas temos que fazer isso para todos os métodos.
Então, também aqui e aqui.
Ao fazer isso, todos eles retornarão falso, o que significa que, se combinarmos três falsos, o
resultado será falso.
Com relação a isso ou à declaração aqui, isso significa que nosso dispositivo não tem root.
Ok, essa é uma abordagem válida, mas exige muito esforço e nós somos hackers superpreguiçosos.
Portanto, queremos seguir o caminho de menor resistência, como acontece com o material eletrônico.
Então, quais são as outras opções que temos?
Vamos limpar isso.
Em vez de aplicar patches em todos eles, podemos optar pela detecção de roteamento principal, que é a seguinte.
Esse método está aqui.
Esse método verifica todos os três e, em seguida, retorna.
Verdadeiro ou falso se o dispositivo tiver sido roteado.
Portanto, ao corrigir esse método aqui, podemos simplesmente dizer que sempre retornamos o valor false.
Portanto, com relação a esse desafio, eu recomendaria que você optasse por essa parte, simplesmente remendando-a nesse
momento.
Adicionando um novo valor constante referente ao registro que está sendo retornado e definindo-o como falso.
Tudo bem.
Agora é possível pausar e retroceder o vídeo caso você queira experimentar.
Vou prosseguir com o verdadeiro desafio e oferecer uma solução para isso.
Está bem.
Aqui estamos de volta à esquerda.
Temos o código do smiley.
E, à direita, temos o código Java descompilado.
Vamos dar uma olhada nisso.
Temos nosso utilitário de raiz de arquivo.
Esta é a nossa classe.
Não estendemos uma determinada classe especial.
É apenas java. lang. objeto.
Esse é o nome do nosso arquivo.
Está bem.
Em seguida, temos o construtor, e aqui podemos ver o método raiz de verificação um.
Está bem.
Se dermos uma olhada à direita, podemos ver.
Ah, isso é estranho porque aqui temos um dispositivo com root.
Mas, sim, esse parece estar faltando no momento à esquerda e isso acontece com frequência no Smiley.
Você pode verificar isso se clicar com o botão esquerdo do mouse nesses números de linha.
Portanto, aqui você tem os números das linhas referentes ao código Java e, se clicar com o botão esquerdo
do mouse, poderá ver os números das linhas referentes ao código do Smiley.
E aqui podemos ver que esses números de linha foram aumentados.
Mas aqui temos alguns, sim, alguns de aparência estranha.
Portanto, estamos tendo 32, 37, 32, 30 novamente.
Portanto, o código smiley é um pouco diferente em relação à ordem do que o código Java.
Já vimos isso nas instruções IF.
O compilador produziu uma ordem diferente que é mais rápida para a CPU executar, em vez de adotar
a abordagem Java.
Portanto, a ordem Java desse código.
Tudo bem.
Mas isso não é um grande problema.
Já vimos isso no passado e, sim, podemos lidar com isso.
Portanto, só precisamos navegar com o código do smiley e precisamos confiar no código do smiley para isso.
Está bem.
Podemos ver que esse é o método de raiz de verificação um.
Este aqui.
Vamos descer aqui, temos o método de verificação de raiz dois, este aqui.
Assim, podemos ver todas as cadeias de caracteres e binários que estão sendo verificados.
Vamos até aqui, temos o método de verificação de raiz três.
Tudo bem.
Se formos até lá, iremos até o final.
O dispositivo está enraizado.
Tudo bem.
E podemos ver isso aqui, na linha dez.
Essa é a linha número dez.
Está bem?
Ele está no final deste arquivo.
Mas, quero dizer, quem se importa?
Portanto, descobrimos isso e, sim, vamos analisar e tentar corrigir o problema.
Portanto, a primeira é uma nova instrução e ainda não falamos sobre ela, mas se dermos uma olhada na instrução
smiley que existe, espero que você tenha preparado sua folha de dicas.
Como você pode ver, não podemos falar sobre todos eles, mas aprendemos muitas coisas sobre o Smiley,
e talvez possamos aplicar esse conhecimento em sua leitura e também entender o que essa instrução faz.
Então, vamos dar uma olhada.
Essa instrução é denominada Invoke static.
Portanto, copie.
Portanto, agora estamos procurando por isso.
Tudo bem.
Invoca um método estático com parâmetros.
Isso é tudo.
Ele apenas invoca o método.
Ele não faz mais nada.
Ok, vamos ver qual método.
Vamos dar uma olhada.
Então, habilitei minha caneta.
E podemos ver que obtivemos capital.
Isso significa que estamos tendo uma referência de classe.
A referência da classe e termina no ponto e vírgula.
Portanto, estamos lidando com o utilitário raiz aqui.
Estamos tendo um problema de raiz.
Ok, então temos esse erro, o que significa que estamos tendo um ponto.
E, depois desse ponto, temos o nome do método.
Nesse caso, verifique o método raiz um.
E assim por diante.
E também podemos ver que o tipo de retorno é booleano.
Está bem.
Portanto, não sabemos ou não sabíamos o que este faz, mas agora sabemos que este executa essa chamada de método.
Portanto, com relação a dois métodos estáticos, não precisamos criar um novo objeto.
Podemos simplesmente usar a classe e, em seguida, o nome do método para invocá-lo.
Ok, então este está apenas executando essa função, mas não faz mais nada.
Portanto, temos a próxima linha.
Esse move o resultado para V zero.
Mas, mesmo assim, vamos verificar isso porque não estamos familiarizados com isso.
Então vamos ver.
Move result, move os valores de resultado da invocação do método anterior para v x.
Tudo bem.
Portanto, o valor de retorno do método anterior, que é este aqui, agora é movido para V zero.
Isso significa nosso zero.
Agora está sendo verdadeiro ou falso?
Depende de qual é o valor de retorno desse método.
Isso significa que teremos 0X1 para verdadeiro e 0X0 se tivermos um falso.
Ok, então vamos dar uma olhada na próxima.
Legal.
Uma instrução if.
Portanto, se v zero não for igual a zero, vamos escrever isso.
Sim, eu ampliei isso e escrevemos isso ao lado.
Sim.
E ainda serve.
Legal.
Portanto.
Nesta linha.
Se.
V zero não é igual a zero.
Saltamos para essa condição.
Isso significa que se nosso v zero for definido como verdadeiro.
Porque, nesse caso, estamos tendo A0X1.
Passamos para a condição um e, se olharmos para a condição um, vejamos, aqui está o rótulo.
Certo, então estamos pulando para baixo e escrevendo 0X1 em v zero, o que é interessante porque
v zero ainda está definido como 0X1, mas, mesmo assim, v zero é 0X1.
É isso que essa linha faz.
E então estamos retornando a esse v zero.
Está bem.
Isso significa que nosso método retornará.
Verdadeiro.
Porque esse está definido como verdadeiro.
Isso significa que nossa detecção de enraizamento está sendo definida como verdadeira e, portanto, nosso dispositivo está enraizado.
Então, vamos dar uma olhada no código mais uma vez para verificar se sim, se tudo está correto.
Neste momento, temos um booleano is device rooted?
Is device rooted true significa que nosso dispositivo está enraizado.
E se esse método retornar verdadeiro, então todo o método retornará verdadeiro.
Isso significa que nosso dispositivo está sendo enraizado.
Portanto, também podemos contornar isso agora mesmo, corrigindo essa instrução.
Portanto, podemos inverter a lógica disso.
Portanto, aqui temos uma opção adicional de aplicação de patches em vez de optar por esta aqui no final.
Também podemos inverter a lógica aqui.
Mas precisamos tomar cuidado com isso porque, no nosso caso, esse método retornará falso.
Portanto, isso não sinaliza que nosso dispositivo está enraizado.
Se agora começarmos a inverter a lógica, esse método dirá que nosso dispositivo está enraizado, mesmo que não seja
o caso em relação a essa verificação.
Portanto, isso é algo que precisamos considerar.
Tudo bem.
Portanto, não optamos por essa opção.
Está bem?
Então, vamos limpar isso um pouco e depois fazer a próxima verificação.
Portanto, temos uma declaração de inadimplência para este aqui.
Está bem.
Portanto, se este for falso, que é o caso, a propósito, da nossa detecção de roteamento, e, portanto, ao inverter a lógica, ele
se tornará verdadeiro.
No final, teremos um dispositivo roteador.
Portanto, não temos ou inverter essa lógica aqui não funcionará para nós neste momento.
Ok, mas se for falso, passamos para o próximo e aqui temos o método de verificação de raiz dois.
Temos a mesma abordagem como esta aqui.
Portanto, temos nosso ponto util de rota de classe.
Vamos escrever dessa forma.
Dot check route method one sorry method two Retorna esse valor booleano.
Esse valor booleano é armazenado em v zero aqui e podemos ver a mesma abordagem.
Então, também aqui se.
B zero não é igual a se B zero não for igual a zero.
Saltamos para essa condição e nosso zero B é a saída do anterior.
Portanto.
Desculpe.
A anterior é apenas esta e esta linha.
Portanto, v zero é igual a.
Vamos escrever isso.
Ponto util raiz.
Método de verificação.
Está bem.
Aqui está.
Está ficando um pouco mais difícil.
Sim, bagunçado, mas acho que podemos continuar com isso.
Certo, então este é este aqui?
Ainda estamos usando o registro y0.
E se este não for igual a zero, saltamos para a condição um novamente, que é esta aqui.
E aqui definimos nosso V0 como um.
Em seguida, retornamos com zero, o que significa que estamos tendo o mesmo caso.
Vamos fazer isso mais uma vez.
Portanto, se nosso v zero não for igual, zero significa que nosso v zero é um, então nosso v zero será definido como um.
Está bem.
E então estamos retornando um.
Está bem.
O que significa que estamos retornando.
Verdadeiro.
O que não é bom, pois assim sabemos que nosso dispositivo tem root.
Portanto, esse método também precisa retornar.
Falso.
Mas.
Ah, desculpe, não também.
Esse método precisa definitivamente retornar false.
Portanto, com relação à abordagem de aplicação de patches, podemos inverter a lógica aqui.
Isso funcionará porque, se você der uma olhada.
Podemos ver que esse método definitivamente sinalizará que nosso dispositivo tem acesso root, pois temos o binário em nosso
dispositivo.
Também podemos ter o superusuário.
Não tenho certeza, mas uma dessas opções com certeza será verdadeira.
Portanto, esse método retornará.
Verdadeiro.
Então, vamos alternar a visibilidade.
Ok, vou esclarecer isso rapidamente.
Portanto, esse método aqui retorna falso para o nosso caso.
Não tem problema.
Mas este aqui retornará.
Verdadeiro.
E, portanto, podemos inverter essa lógica aqui.
Isso deve funcionar.
Sim.
Está bem.
Mas vamos facilitar um pouco as coisas para que não tenhamos que fazer remendos.
E vice-versa.
Quero apenas mostrar a você todas as possibilidades de resolver esse desafio agora mesmo.
Você também pode tentar fazer isso em si mesmo mais tarde.
E se tiver dúvidas, sim, escreva-me uma mensagem.
Fico muito feliz quando recebo feedback sobre desafios como esse.
E, é claro, faço o possível para ajudá-lo nisso.
Está bem.
Tudo bem.
Portanto, essa também é uma abordagem que deve funcionar.
Então, o que vem a seguir?
Está bem.
Estamos nesse método aqui.
Sim, já falamos sobre isso.
Acabamos aqui.
Caso contrário, falamos sobre a declaração verdadeira.
Mas agora precisamos acessar os padrões e a declaração padrão mais uma vez, exatamente da mesma forma.
Mas tudo bem, agora é um pouco diferente.
Vejamos.
Muito bem, vamos fazer isso.
Invocamos esse método aqui.
Método de raiz, um método de verificação utilitário de raiz três.
Portanto, em relação a essa linha e a essa linha, isso significa uma última chance de escrevê-la de forma limpa.
Então vamos ver.
V zero é o utilitário raiz.
Verifique o método três e, em seguida, teremos uma instrução IF.
Se.
Oh, isso é interessante.
Se v zero for igual a zero, saltamos para a condição zero.
Tudo bem.
Melhor condição?
Zero.
Há a condição zero.
Legal.
Isso significa que estamos escrevendo zero em V zero.
Está bem.
Em seguida, vamos para o rótulo um, vamos para um, que é este aqui, e estamos retornando.
Portanto, estamos retornando.
B0.
Tudo bem.
Isso é diferente.
Que bom.
Então, o que temos aqui?
Se esse método agora retornar zero, então esse dispositivo está sendo sinalizado como não enraizado.
Mas o problema desse método é que só podemos alcançar esse método, esse ponto aqui.
Se este for falso e se este for falso, só então poderemos chegar a este ponto
aqui.
Isso significa que, se um deles não for falso, acabaremos em um dispositivo com root.
Tudo bem.
Portanto, é assim que a lógica é implementada no somali.
Talvez seja um pouco confuso no início, mas se você repassar isso mais uma vez e,
sim, escrever exatamente como fizemos em um papel inteiro, então você perceberá que, ok, é
assim que a lógica funciona.
E sim, talvez então não seja mais tão difícil.
Eu realmente o incentivo a escrevê-lo da seguinte forma, talvez um pouco mais limpo do
que eu.
E talvez também, sim, mais completo do que eu.
Mas essa é uma abordagem muito boa para entender.
Somali.
Ok, agora vamos ver.
Portanto, se esse for o caso, passaremos para a Condição zero.
A condição zero estava aqui.
Está bem.
E então, deste, pulamos para este e, sim, pulamos esta parte aqui.
Tudo bem.
Portanto, ao analisar isso, encontrei duas opções adicionais de aplicação de patches, ou pelo menos uma.
A outra solução que vejo no momento é com relação aos rótulos.
Neste caso.
Este aqui.
E sim, também este, por exemplo.
Portanto, esses rótulos definem e ramificam a instrução.
Temos nosso código, digamos que esta seja uma verificação, vamos chamá-la de raiz da verificação e assim por diante.
Com base nisso, há uma decisão se formos para a esquerda, que é, por exemplo, verdadeira,
que é, nesse caso, a condição em que um dispositivo está enraizado.
E se formos para o falso?
E, depois, não enraizado.
É isso que queremos ter.
E essa declaração falsa aqui não está relacionada a duas condições.
Primeiro, trata-se de duas condições zero.
Condição de sublinhado zero, portanto, também podemos alterar o rótulo para realizar essa tarefa.
Mas sim, para manipular a instrução de salto, para não ir para este lado, para ir sempre para este lado.
Essa também é uma solução muito boa, em minha opinião.
E sim, sinta-se à vontade para experimentar.
Portanto, a solução mais fácil que quero lhe mostrar agora é a seguinte.
Temos apenas dois valores booleanos em nossa função aqui.
Temos este aqui e este aqui.
Isso define o dispositivo como falso ou não o dispositivo.
Desculpe, a detecção de roteamento é falsa, o que significa que não foi roteada.
Este aqui define o dispositivo como verdadeiro.
Desculpe.
A detecção de roteamento como verdadeira.
O que significa que o dispositivo é roteado.
Portanto, a maneira mais simples de corrigir essa detecção de roteamento é alterar esse valor para 0X0.
Ao fazer isso, o dispositivo também não será roteado.
E, portanto, podemos executar nosso aplicativo como um ano normal, como um aplicativo normal.
Tudo bem.
A outra solução é esclarecer isso rapidamente.
Antes de sairmos dessa.
Neste ponto, podemos aplicar um novo comando ou uma nova
instrução, que é a barra constante 4V00X0.
Portanto, podemos simplesmente escrever essa instrução mais uma vez, logo antes de sairmos dessa função.
Isso significa que não importa o que aconteça, mesmo que o nosso registro v zero esteja sendo definido como um nesse ponto aqui,
o que significa verdadeiro, estamos sobrescrevendo v zero nesse ponto.
Mito.
Falso.
E então estamos retornando o último valor.
Este aqui.
Está bem.
Portanto, mostrarei essas duas abordagens neste vídeo agora mesmo e farei um vídeo adicional sobre
como corrigir esses jump labels.
Está bem.
Portanto, uma correção fácil é simplesmente esta.
Sei que isso é ridículo, mas deve funcionar.
Se você der uma olhada nisso, todos os métodos agora retornam falso porque não há mais a opção de retornar
verdadeiro.
Muito bem, vamos dar uma olhada.
Portanto, desinstale o ADB.
Desinstalar o ADB e instalar o apk antigo.
Sucesso.
Vamos verificar.
Aqui está.
O dispositivo não tem root.
Agora é possível fazer login.
E se você clicar em login, teremos nossa bandeira porque, sim, temos uma habilidade insana com sorrisos.
Legal.
Portanto, isso é tudo o que precisamos fazer.
Sei que parece super simples e você pode pensar: "Ah, bem, foi realmente tão fácil assim?
Sim, mas trabalhamos muito para entender que é assim tão fácil porque fizemos engenharia reversa desse aplicativo
e descobrimos o que está acontecendo.
Está bem.
Nesse caso, esse é um bom truque para verificar.
Está bem.
Há apenas dois estados booleanos disponíveis aqui, mas isso vem com a prática e a experiência
no Smiley.
Não se preocupe com isso se você tiver alguma coisa realmente complexa ou se tiver se esforçado muito para
isso.
Isso é absolutamente normal e nem sempre é fácil corrigir esse problema.
Muito bem, vamos reverter essa alteração.
Portanto, agora temos de volta a alteração original.
Se construirmos isso, nosso dispositivo ainda estará sendo sinalizado como roteado.
A outra abordagem é.
Sim, introduza uma nova instrução sorridente ali.
Portanto, pouco antes de sairmos, substituímos esse registro que retorna verdadeiro ou falso para esse valor
booleano.
E sim, vamos criar esse aplicativo mais uma vez e instalá-lo.
Vou avançar rapidamente agora, então nos veremos em alguns instantes.
E sim, você pode ver que este também funciona bem.
Sim.
Tudo bem.
Vamos dar uma olhada na saída descompilada, como nossa detecção de roteamento funciona agora.
Portanto, essa é a nossa versão corrigida.
Portanto, esta é agora esta versão. Aqui estamos substituindo o valor de retorno por false.
Vamos ver como o código Java se parece com isso.
Joguei seu jogo.
E lá vamos nós.
Este foi adicionado agora.
Portanto, não importa qual seja o primeiro resultado, ele retornará falso.
Isso é o que adicionamos ao introduzir essa nova instrução logo antes de sairmos dessa função.
Tudo bem.
Portanto, esse foi um desafio muito difícil no momento.
Está bem.
Esse patch foi fácil, mas entender o que está acontecendo não foi tão fácil assim.
E, portanto, não importa como isso funcionou para você, se você conseguiu resolver isso ou não,
e se você também passou por isso mais uma vez e resolveu, não importa se você recebeu alguma ajuda em relação
ao vídeo Solução aqui.
Mas se você já passou por isso e entendeu o que está acontecendo e se conseguiu reproduzir
isso, então este cinto é para você agora.
Aqui está.
Tudo bem.
Farei um vídeo bônus adicional relacionado a esse desafio porque, sim, também foi
muito interessante para mim saber que já existem tantas opções para resolvermos isso.
Portanto, é muito bom ver quantas oportunidades já temos no momento, pois estamos apenas na metade
do tópico múltiplo.
Portanto, teremos muito mais poder no próximo capítulo, quando falarmos sobre métodos e também, sim, introduzirmos
ou inserirmos instruções mais complexas.
Portanto, o vídeo de bônus virá logo após este vídeo.
Mas se você já tiver corrigido esse salto condicional aqui nos rótulos, é claro que poderá pular essa etapa
se estiver bastante confiante para fazer isso.
É claro que você pode pular essa parte.
Isso não é realmente necessário.
Continuaremos com os objetos, que é o último grande capítulo de nosso pequeno processo de aprendizado.
E, ao fazer isso, sim, obteremos ainda mais potência e invadiremos esses aplicativos.
Então, vejo você lá.