Bentornati.
Diamo un'occhiata ai blog per iniziare.
Come sempre, diamo un'occhiata al nostro lato positivo o al codice.
Poi scriviamo il nostro codice e successivamente lo analizziamo.
Quindi, andiamo.
Ecco il nostro codice totale e abbiamo il nostro oggetto giocatore.
Questo oggetto giocatore ha delle vite eppure abbiamo applicato il valore a 999, il che è stato davvero sorprendente.
Ben fatto.
Ma poi abbiamo il rilevamento delle collisioni.
Quindi il nostro giocatore viene colpito da un alieno.
Sparato da un alieno dal boss alieno, o quello che è.
Il giocatore perde una vita.
Ed ecco il nostro controllo if, la nostra prima dichiarazione if.
Se il giocatore ha meno di zero vite, la partita è persa.
In caso contrario, il giocatore risponderà e attenderà finché non verrà colpito di nuovo o finché non vincerà la
partita.
Questo è il nostro cerchio, il nostro codice funzione, il nostro grafico di flusso qui.
Ora lo codificheremo, ma solo ad alto livello, come abbiamo descritto qui.
Quindi creiamo la nostra applicazione e diamo un'occhiata alla parte degli smiley.
Come funziona il flusso di controllo?
Come vengono preparate le dichiarazioni if in questo codice multiplo.
Diamo quindi un'occhiata.
Andiamo.
Ok, eccoci alla nostra macchina virtuale Ubuntu e vediamo di codificare rapidamente questa applicazione.
Questa volta dobbiamo occuparci un po' di più dello sviluppo di applicazioni Android, ma sentitevi liberi di unirvi a me.
Lo codifichiamo insieme, ma non preoccupatevi, potete anche mettervi comodi e guardarmi mentre codifico,
perché dopo vi fornirò l'applicazione.
Questo non è un corso di sviluppo di applicazioni.
Questo è un corso di app hacking.
Voglio darvi alcuni spunti per lo sviluppo di applicazioni Android che vi consentiranno di fare determinate cose.
Ad esempio, scrivere piccoli pezzi di codice che vi aiutino a proseguire e analizzare le applicazioni o cose del
genere.
Ma sì, come già detto, potete anche appoggiarvi a questo e guardarmi mentre codifico.
Ok, sentitevi liberi.
Come preferisci.
Quindi andiamo.
Andiamo a Strumenti Android studio bin Bash Studio come.
Va bene.
L'ID è in fase di caricamento.
Ci vediamo tra poco.
Siamo tornati proprio ora e questo è stato l'ultimo progetto a cui abbiamo lavorato, quello degli smile.
E si può invertire con successo questo metodo qui.
Congratulazioni ancora una volta per questo.
Questa è davvero una cosa fantastica e avete fatto un buon lavoro.
Per ora vogliamo separarli, quindi creiamo un nuovo progetto.
Si va nel file, si chiude il progetto.
Poi possiamo o fare clic su Crea nuovo progetto.
Attività MBTI e nomino questo strumento smiley.
Lingua.
Io e Chava torniamo a Marshmallow.
Sì.
Finitura, che potrebbe richiedere un po' di tempo fino al completamento del processo di classificazione.
Quindi ci rivedremo tra poco.
Pochi istanti dopo, eccoci di nuovo qui.
Va bene.
La prima cosa da fare è creare la nostra classe giocatore.
Entriamo in comm a pecking smiley per fare clic con il pulsante destro del mouse su una nuova classe java e diamo un nome a questo giocatore.
Ops.
Va bene.
Ok, diamo al nostro giocatore un livello di potenza.
Quindi in potenza è uguale a dieci.
Ora abbiamo bisogno di un campo istanza aggiuntivo.
Abbiamo bisogno delle nostre vite per questo giocatore.
Quindi abbiamo cinque vite.
Va bene?
Ora dobbiamo simulare questa situazione.
Il nostro giocatore lo capisce.
Possiamo farlo in due modi.
Possiamo scrivere un'intera applicazione con una bella musica, animazioni fantasiose e molte esplosioni.
Oppure possiamo farlo in modo pigro e inserire semplicemente un pulsante.
Premendo questo pulsante, il nostro giocatore viene colpito e si avvicina al pulsante in modo pigro.
Ma sentitevi liberi di codificare la vostra applicazione di gioco per simulare questo compito.
Dipende da voi.
Quindi, creiamo un pulsante nel nostro layout e, premendo questo pulsante, i codici dei pulsanti sono
funzione.
E questa funzione lo simula.
Il nostro giocatore è stato colpito da un oggetto.
Scriviamo questo.
Il metodo per farlo.
Quindi abbiamo il void pubblico che non ci serve come valore di ritorno per questo get hit.
Penso che questo lo descriva nel modo migliore.
Quindi se il nostro giocatore viene colpito, perdiamo una vita.
Fin dall'inizio.
Il meno della vita.
Meno.
Ora dobbiamo verificare se il giocatore può ancora giocare.
Quindi, se abbiamo più di zero vite rimaste, zero vite rimaste.
Se questo punto vita è maggiore di zero, possiamo andare avanti.
Altrimenti perdiamo la partita.
O diciamo che perdo la partita perché non è stata colpa tua.
Se vieni colpito, hai perso.
Ok.
Facciamo anche questo capitale.
Sembra buono.
Ora dobbiamo introdurre una nuova istanza, perché dobbiamo inserire del codice che non faccia esplodere
l'applicazione e la renda inutilmente complessa.
Nel mio caso, scelgo uno stato booleano e lo inizializziamo con true e diciamo che se lo stato è uguale a true, possiamo
andare avanti.
Altrimenti questo status cade e io perdo.
Va bene.
Quindi questo stato è uguale a falso.
Se perdiamo la partita e qui possiamo impostarla ancora una volta, non sarebbe necessario, ma non fa male.
OC Questo metodo mi sembra perfetto anche per voi.
Ok, buono a sapersi.
Ora dobbiamo posizionare il nostro pulsante nel layout e dobbiamo farlo nell'attività principale, perché qui abbiamo
un'attività e un'attività, alcuni contenuti dello schermo.
Pertanto, il contenuto dello schermo ha un layout.
Questo layout si trova all'interno dell'attività principale di layout delle risorse.
Quindi questo layout è descritto da questo file XML qui possiamo andare nel codice e poi abbiamo la struttura
XML.
Sembra un po' complesso e opprimente.
Lo so, ma lo faremo insieme se continuerai a fare il coding con me.
Altrimenti, rilassatevi e godetevi lo spettacolo.
Quindi abbiamo il nostro campo di testo e apportiamo una modifica.
Chiamiamola "UDC".
Se torniamo indietro, possiamo vedere che questo campo di testo qui è cambiato.
Salve.
Ce l'hai fatta.
Va bene, facciamo un po' di più.
Sì, in stile hacker.
Quindi, sfondo Android, fornisco un nuovo colore di sfondo.
Rendiamo questo sfondo nero uguale e poi 000.
Ok, se tornate indietro, è nero come il nostro testo.
Pertanto, non abbiamo più testo visibile.
Rendiamo questo testo bianco.
Possiamo scegliere aggiungi colore, slash slash wide, oppure possiamo anche inserire f, f, f, f, f, f, a proposito, torniamo
alla funzione aggiungi colore.
Quindi, se scegliamo questo, possiamo vedere il testo ampio e il colore di aggiunta è il nostro file dot rc delle risorse.
Quindi troviamo questo nei colori dei valori e qui abbiamo alcune etichette definite.
Possiamo anche scegliere questo, ad esempio, che ha un aspetto ancora più approssimativo.
Quindi facciamo così.
Sì.
Ecco fatto.
Ora sembra tutto molto complicato.
Ok.
Aumentiamo un po' le dimensioni del testo.
30 DPI.
Ecco fatto.
Tutto ciò che ho fatto non era realmente necessario, ma rende l'app un po' più interessante.
Già.
A me sembra che sia bello.
Quindi ora passiamo alla parte vera e propria.
Introduciamo o sì, inseriamo il nostro pulsante.
Possiamo trovarlo nel pulsante comune e trascinarlo semplicemente all'interno.
Ora abbiamo questo allarme.
Questa vista non è vincolata, il che significa che abbiamo smartphone diversi con risoluzioni diverse e questo
pulsante può essere posizionato ovunque.
Dipende dalla risoluzione tagliata.
Quindi è in giro per il nostro layout.
Questo è un aspetto che non vogliamo avere, perché a volte questo pulsante potrebbe essere fuori dallo schermo e quindi
non si può fare clic su di esso.
Vogliamo allineare questo pulsante sotto il nostro testo qui, e possiamo farlo semplicemente trascinandolo
da questo punto.
A questo punto, fluttua per un momento, ma continuate a fare clic, poi si attaccherà a questo.
Ok.
Ora il pulsante si trova direttamente sotto questo, ma non è ancora menzionato.
Dove si trova?
Più a sinistra.
Di più, giusto?
Non è assolutamente centrato per inviare questo pulsante, facciamo clic sul lato destro e trasciniamo anche
questo qui.
E lo facciamo ancora una volta per il lato sinistro.
E ora possiamo esserne certi.
Ok, questo pulsante è stato inviato.
Questo layout di vincoli è sì, non è così nuovo, ma prima era molto più difficile, quindi sono abbastanza contento che l'abbiano
introdotto.
Ok.
Torniamo nel cappotto perché non mi piace che questi elementi si attacchino così tanto tra loro.
Quindi Android corrisponde alla top 34 DPI.
Il DPI, tra l'altro, è profondo ed è una specie di pixel.
Ma per quanto riguarda la risoluzione.
Quindi questo significa che non importa cosa.
34 sarà 34 su tutte le risoluzioni dello schermo.
È come un pixel in un modo migliore.
Ecco fatto.
Ora sembra molto bello.
Torniamo all'attività principale.
Ok.
Ora dobbiamo collegare questo pulsante al nostro metodo.
E questo metodo deve essere definito qui, perché questo metodo ha la conoscenza di questo pulsante.
Questo pulsante è posizionato nel layout principale dell'attività.
Pertanto, non possiamo usare questo metodo qui, per essere colpiti direttamente, perché questo metodo
non sa che questo pulsante esiste qui.
Ok, questo è il nostro file di layout.
Creiamo ora un nuovo metodo in public void e simuliamo la collisione.
Inoltre.
Ecco fatto.
E qui possiamo richiamare il metodo "player got hit".
Per collegare il pulsante a questo metodo, dobbiamo eseguire alcune operazioni interne ad Android.
La prima cosa da fare è applicare o aggiungere questa vista come parametro.
Quindi inseriamo questa vista come parametro e questa vista sarà in seguito il nostro pulsante che verrà collegato
a questo metodo.
È vero, non voglio approfondire l'argomento perché questo non è un corso di sviluppo di app.
Voglio solo mostrarvi queste cose per permettervi di scrivere le vostre applicazioni.
L'approccio è sempre lo stesso.
Quindi, se volete simulare o testare alcune cose, questo può essere molto utile per voi.
E sì, è un po' complicato, ma lo affronteremo insieme in questo momento.
Abbiamo quindi la nostra vista qui e questa vista è ora il pulsante.
Ma il pulsante non ne è a conoscenza in questo momento.
Quindi dobbiamo anche dire al pulsante che, se facciamo clic su questo, il pulsante deve attivare questo
metodo.
Questo deve essere fatto nell'attività principale.
Pertanto, entriamo in patent tech e diciamo Android on click, e ora possiamo usare questa funzione
qui.
Ok.
Quindi, se si fa clic su questo pulsante, viene richiamato questo metodo e questo qui è il pulsante che otteniamo.
Sì, in modo da ottenere l'ascoltatore dell'evento on-click combinato con questo metodo.
Sì, è un po' complicato ed è per questo che voglio mostrarvelo subito, perché se iniziate
a sviluppare applicazioni Android, è un po' difficile.
Nel mio caso, ho faticato molto anche solo per cambiare un semplice testo nella nostra applicazione.
È stato molto difficile per me.
Abbiamo quindi il nostro pulsante collegato in questo momento.
Creiamo il nostro oggetto giocatore e chiamiamo questo metodo.
Quindi, facciamo giocare un nuovo giocatore e ora possiamo chiamare il metodo player got hit get hit.
Questo è un cambiamento.
Ok.
Se si preme questo pulsante, questo metodo viene chiamato e questo metodo lo simula.
Il nostro giocatore è stato colpito.
Ops.
Va bene.
Questo funzionerà.
Non l'ho testato al momento, ma sono abbastanza sicuro che sia così.
Ma per questo abbiamo bisogno di un qualche tipo di output visivo, altrimenti non possiamo esserne certi.
Ed è qui che entra in gioco questo campo di testo.
Se torniamo alla nostra attività principale, chiudiamo questa che è un po' più semplice.
Usiamo questo testo qui per visualizzare le vite dei giocatori in questo momento.
Sì, è una buona idea.
Ok.
Entriamo in questa e creiamo una nuova vista di testo qui.
Ok.
E questa vista di testo deve essere collegata a questa qui.
E quindi entriamo in questa.
Questo ha un ID, si chiama vista testo e ora è come se fosse all'interno di JavaScript.
Quindi chiamiamo un metodo che trova questo ID e poi possiamo assegnare questa vista di testo a questa
vista di testo e poi possiamo usare questo oggetto per stampare il testo o fare altre cose.
Va bene, facciamolo.
È necessario farlo nel metodo on create, perché questo crea il nostro layout.
Dobbiamo avere il riferimento qui.
Quindi la visualizzazione del testo è uguale a come ottenere questo riferimento?
Al momento esiste un metodo chiamato Trova vista per ID.
E qui dobbiamo fornire un ID risorsa, questo ID risorsa.
Ops.
Scusate, un'attività principale è questa qui.
E questo è un riferimento da parte della classe di risorse.
Quindi, per trovarlo, dobbiamo usare la classe di risorse ID pensato e poi abbiamo i nostri ID nel nostro layout perché questa classe di risorse
tiene traccia dei nostri ID nel nostro layout, vogliamo avere la nostra vista di testo.
Pertanto, facciamo clic su questo ID di visualizzazione del testo.
Ok.
Ad essere sinceri, anche questo è complicato.
Sì.
Ma facciamo ancora una volta così.
Abbiamo qui la nostra vista testo.
Questa vista di testo si trova in questo layout e questa vista di testo ha un ID.
Creiamo un nuovo oggetto vista testo e poi usiamo questo oggetto o assegniamo questo oggetto, questa
vista testo nel nostro layout e possiamo indirizzarlo con il nostro ID.
E poi l'idea del nostro elemento che vogliamo affrontare per essere sicuri al 100% di doverlo tipizzare.
Non sono sicuro del perché non ci sia un messaggio di errore qui, e non sono nemmeno sicuro che questo sia ancora comune al giorno
d'oggi.
Ma quando ho iniziato lo sviluppo di applicazioni Android, abbiamo dovuto fare il typecast.
Bene, ora abbiamo la nostra vista testo.
Questo è il nostro oggetto ed è collegato alla nostra vista di testo del layout.
Possiamo semplicemente scrivere testo, visualizzare, impostare testo e ora vivere.
E qui forniamo le vite dei nostri giocatori.
Non c'è problema.
Questo è il nostro corso accelerato di sviluppo di applicazioni Android per quanto riguarda l'assegnazione di oggetti e la modifica del testo delle visualizzazioni
di testo.
È un po' fuori tema, ma può essere molto utile se si vuole giocare con questo sistema.
Pertanto, vorrei includerlo nel corso.
Ok, costruiamo questa applicazione.
Bene, facciamo clic su localizza.
Ecco l'applicazione.
Facciamo in modo che la nostra connessione ITB sia già collegata.
Installiamo questa applicazione.
E ora abbiamo il contenuto dello schermo di tutta la macchina del tempo.
Ecco l'applicazione "smiley tool".
Abbiamo iniziato.
Salve, Udemy.
Ora simuliamo che il nostro giocatore venga colpito.
Bello.
Hai solo quattro vite.
Tre, due, uno, zero.
E siamo anche negativi perché non abbiamo ancora fatto qualcosa con il valore del nostro stadio giocatore.
Ma va bene così.
Per ora, vogliamo analizzare o imparare qualcosa sulle dichiarazioni if e questo è sufficiente per farlo.
Ok, diamo un'occhiata veloce a questo aspetto.
Nel prossimo video faremo un approfondimento su questa dichiarazione if.
Quindi f k a dh.
Qui abbiamo due file e possiamo vedere che abbiamo un multiplexing.
Questo potrebbe essere dovuto alla retrocompatibilità FA di questa applicazione, ma non influisce sul nostro
approccio di reverse engineering.
La nostra classe potrebbe essere all'interno di questo o di questo.
Io sceglierei prima le classi due.
Scusate, le classi sottolineano qualsiasi cosa.
Capite cosa intendo?
Qui.
Bene, ecco.
L'applicazione è stata hackerata.
Vediamo, ora sto aprendo questo con le procedure guidate per fare il codice.
Smiley per giocare.
SMILEY Ecco fatto.
È la nostra classe.
Attiviamo Java.
Va bene.
Abbiamo la nostra classe di giocatori.
Abbiamo una superclasse, un oggetto che viaggia, i nostri campi di istanza.
Non ci interessa il costruttore.
Questo è il nostro metodo al momento.
E la TV può vedere la prima nuova linea.
Se c'è meno è uguale a zero, forse siamo a zero.
E poi questa condizione a cui dobbiamo anche andare e sì, cose del genere.
In questo video, ho voluto mostrarvi come potete scrivere semplici applicazioni Android che vi aiutano a simulare determinate
attività.
Questo può essere molto utile se si vuole giocare con le funzioni degli smiley.
Era un po' fuori tema rispetto all'intero processo di sviluppo, ma credo sia utile per
voi.
Pertanto, l'ho incluso in questo video.
Ok.
Per ora è tutto per questo video.
Il prossimo, invece, è un'analisi approfondita di questo file.
Quindi non vedo l'ora di vedervi lì.