Quando torno in questo video, vogliamo dare un'occhiata alla struttura del file di uno smiley, perché
abbiamo scavato direttamente in questo file e non abbiamo parlato della struttura stessa.
Quindi è una cosa che vogliamo fare subito.
E vedrete che non è davvero complicato.
Abbiamo la struttura per la maggior parte del tempo, credo per il 95%.
Diamo quindi un'occhiata alla prima riga.
Abbiamo la nostra classe di punti public e poi abbiamo questa L maiuscola, che significa che abbiamo un riferimento alla
classe e che termina con il punto e virgola.
Quindi abbiamo il riferimento alla classe del giocatore.
Ok, non è stato davvero difficile.
Nella riga successiva abbiamo questo punto super e significa che la nostra classe player è una sottoclasse di
questa qui.
In questo caso si tratta di un oggetto che viaggia.
Per fare un altro esempio, se si guarda alla nostra attività principale, la nostra superclasse sarebbe activity, perché
la nostra attività principale è una sottoclasse di questa classe activity.
Va bene.
Quindi non è così difficile.
Poi abbiamo il nostro sorgente e questo è giocabile su Java, ma credo che su questo sia già stato detto tutto.
Bene, allora abbiamo questo hashtag all'inizio della riga e questa è una sorta di separazione.
Ok, credo di dover essere un po' più preciso su questo punto.
Il tag hash significa semplicemente un commento e quindi il testo viene ignorato.
Il testo dietro questo hashtag non è un'istruzione.
Questo è semplicemente il testo.
Questo testo è stato creato dallo strumento APK per aiutarci a comprendere la struttura del file.
Viene utilizzato anche per fare riferimento ad alcuni valori.
Ad esempio, abbiamo alcuni valori esadecimali e direttamente dietro di essi abbiamo una rappresentazione decimale
dopo un tag hash.
Ciò significa che lo strumento APK ci fornisce alcune informazioni sui campi statici, sui metodi privati
e virtuali e cerca anche di aiutarci a convertire i valori esadecimali in decimali, il che è piuttosto piacevole.
Quindi, per riassumere, un hashtag significa un commento e in questo caso è una sorta di separatore,
ma solo visivo, non tecnico.
Va bene.
Abbiamo quindi diversi hashtag per diversi significati, ma tra questi abbiamo spesso qualcosa
chiamato annotazioni e queste annotazioni sono nelle nostre classi.
Se utilizziamo una classe all'interno della nostra classe player, il file smiley deve avere questo riferimento
e questo è il suo scopo.
Nel nostro caso, non abbiamo in una classe, ad esempio, un enum o qualcosa di simile; daremo un'occhiata alla nostra
applicazione di pagamento dello spazio per familiarizzare anche con questo.
Va bene.
Poi, abbiamo questo campo statico, riga sei.
E i Campi statici iniziano con un tag hash sotto questo.
Abbiamo tutti i campi statici di questa classe.
In questo caso, abbiamo solo un campo statico che è lives.
Si tratta di un tipo, un intero corretto.
Poi abbiamo questi campi di istanza che iniziano anch'essi con un tag hash.
Ora abbiamo tutte le variabili della classe.
In questo caso, abbiamo potenza e scudo.
Ho aggiunto una nuova variabile di istanza qui.
Abbiamo poi un nuovo hashtag che inizia con i metodi diretti e riguarda i metodi privati,
i metodi statici e anche i costruttori relativi ai metodi statici.
Questo è un po' speciale perché il bytecode Dalvik ha un certo riferimento per questo.
Quindi non vi si trovano metodi statici.
In questo caso, possiamo concentrarci sui costruttori e sui metodi privati.
Ok.
Infine, abbiamo questo tra i metodi, il che significa che abbiamo i nostri metodi pubblici laggiù
e che questa è l'intera struttura semplificata.
E sì, se si acquisisce familiarità con questo, si può navigare ancora più facilmente all'interno di questo file.
Per esempio, se si cerca un certo campo di istanza, si va su questo file, si controlla
il segno dell'hashtag e si vede che qui ci sono tutti i miei campi di istanza.
Ok, credo di dover essere un po' più preciso su questo punto.
L'hashtag significa semplicemente un commento.
Pertanto, il testo viene ignorato.
Il testo dietro questo hashtag.
Non si tratta di un'istruzione.
Si tratta semplicemente di un testo.
Questo testo è stato creato dallo strumento APK per aiutarci a comprendere la struttura del file.
Viene utilizzato anche per fare riferimento ad alcuni valori o tipi, come vediamo qui dopo un tag hash.
Ciò significa che lo strumento APK ci fornisce alcune informazioni sui campi statici, sui metodi privati
e virtuali e cerca anche di aiutarci a convertire i valori esadecimali in decimali, il che è piuttosto piacevole.
Quindi, per riassumere, un hashtag significa un commento e in questo caso è una sorta di separatore,
ma solo visivo, non tecnico.
Va bene.
Ok.
Perfetto.
Tiriamo fuori la nostra applicazione spaziale e navighiamo un po' all'interno di questo file, dando anche
un'occhiata alla dichiarazione delle annotazioni.
Andiamo.
Bene, aggiungiamo la nostra macchina virtuale Ubuntu e controlliamo questo file.
Quindi andiamo nello spazio delle applicazioni della nostra directory e decompiliamo.
Insomma, non ha molta importanza o non ha importanza.
Utilizziamo l'approccio di epic tool perché l'output del JDK è un po' diverso e vogliamo guardare
il codice smiley.
Quindi abbiamo bisogno della versione decompilata dello strumento APK.
Facciamo questo ancora una volta insieme che abbiamo lo stesso Stato.
Quindi strumento epico il e poi riquadro spaziale.
Sì.
Poi entriamo in questa directory e apriamo l'intera directory con il codice di Wizard Studio.
Ecco fatto.
L'abbiamo aperto anche accanto a noi con Chad.
Poi abbiamo il codice Java, che è un po' più facile da navigare e leggere.
Così lo spazio dipinge il complesso e Shadi, scusatemi.
E questo.
Bene, allora troviamo questa classe di giocatori.
Usiamo questo qui.
Deve essere compilato e indicizzato.
Utilizziamo anche questo campo di classe.
Credo che questo campo di classe sia sufficiente.
Se si usa solo questo, non c'è tutta questa distrazione.
Abbiamo questo nel lettore di componenti.
Va bene.
E mettiamo l'apertura nel codice somalo.
Abbiamo quindi i componenti.
Gioca con noi, Molly.
Ho eliminato questo e abilitiamo Java anche se non si tratta di un codice Java.
Bene, ci siamo.
Esaminiamo ancora una volta questo file.
Ecco la mia tavoletta grafica.
Facciamo un'immersione in questo caso per vedere la riga uno o la riga uno.
Questa qui, abbiamo la nostra classe public, poi abbiamo questa definizione di classe L Poi questo termina con il
punto e virgola.
Quindi abbiamo anche la definizione della classe player, ma questa volta abbiamo un nome di pacchetto diverso, perché siamo all'interno
di un'applicazione diversa.
Ma questa è la nostra classe di giocatori.
Questo qui.
Ok, ora abbiamo il super e questo bello, ora ne abbiamo uno diverso.
Ciò significa che questo componente comm Artemis è la nostra classe base e la nostra classe player è la sottoclasse di questa e
possiamo vederla qui.
Stiamo estendendo questa classe.
Questo è il significato di questa linea.
Poi abbiamo il nostro giocatore di salsa.
Di questo abbiamo già parlato.
Non è così difficile.
Poi abbiamo le annotazioni.
E inizia qui e finisce qui.
Cosa abbiamo qui?
Sono arrivate le annotazioni.
Un famoso tessitore di annotazioni tirate.
Questa sembra essere una classe.
Possiamo trovare questa classe qui?
Sì.
Stiamo importando questa classe in questa riga.
Per questo motivo, per essere mercificato deve avere un riferimento a questa classe.
E questo è ciò che fa questa annotazione.
Il prossimo.
Abbiamo questo qui.
Abbiamo le grandi annotazioni.
Ricordate, giocatore di classe, stato di dollari.
Abbiamo già parlato del segno del dollaro, il che significa che questo è il nostro giocatore di classe.
Questo è il nostro separatore, questo dollaro.
Oppure lasciatemi disegnare questo con un colore diverso.
E poi abbiamo questo in una classe, nella nostra classe giocatore, che significa stato.
Quindi questo è il nostro in una classe.
Vediamo dove si trova questa classe qui.
Qui.
Quindi abbiamo un riferimento da una classe diversa nella nostra classe giocatore e questo è ciò che abbiamo
qui.
Quindi, se date un'occhiata a questa classe, lasciatemi parlare rapidamente con lo schermo.
Ecco fatto.
Oh, ok.
È all'interno di questa classe, proprio qui.
Quindi definiamo questo stato, che è un enum, e abbiamo questo enum direttamente nella nostra classe.
Quindi può essere nella nostra classe, una classe completamente nuova o un enum, per esempio.
Questo influisce anche su questo enum, ed è per questo che abbiamo questo qui, lo stato del giocatore.
Ok.
Pulisco velocemente, poi possiamo andare avanti.
Sì, questo è tutto per i file di annotazione o per la descrizione di questa annotazione qui.
Abbiamo le nostre due referenze.
Abbiamo questo vivaio comune e abbiamo anche il nostro OC statale.
Poi ci sono i campi statici.
Lo vediamo con l'hashtag iniziale qui e con i campi statici.
Vite predefinite.
Nome dello sprite.
Scudo del nome dello sprite.
E questi sono qui.
Quindi, puliamo tutto velocemente e poi dobbiamo lasciare questa traccia un po' a noi.
Ok.
La statica pubblica vive.
Questo qui.
E si può notare che iniziano esattamente allo stesso modo.
Statica pubblica.
L'ultimo default finale.
Pubblico statico finale.
Ok, abbiamo questo finale qui nelle vite predefinite, ma questo finale è all'interno della nostra definizione di tipo qui.
E abbiamo anche questo valore cinque.
Dovremmo portarlo qui e qui.
Questi sono i nostri tre valori statici pubblici che si trovano all'interno di questo qui.
Poi abbiamo il nuovo hashtag, questo, che ci dice che i campi statici sono alla fine.
In questo caso abbiamo nuovi campi, campi di istanza.
Abbiamo tre campi di istanza.
Uno, due, tre.
Diamo un'occhiata.
Li abbiamo qui.
Questo è un campo istantaneo, pubblico e di vite, e questo è un punteggio.
E qui abbiamo il nostro Stato esattamente come questo qui.
Forte.
Anche questi campi di istanza finiscono qui, perché ora abbiamo il nostro metodo diretto.
Metodi diretti.
Vi ricordate ancora a cosa servono?
Certo che si può.
In questo caso, i metodi diretti vengono utilizzati per i metodi e i costruttori privati.
Vediamo, abbiamo questo costruttore che restituisce void.
Non vediamo questo costruttore qui, ma è ovviamente disponibile.
Lo sviluppatore non ha creato un codice per questo, ma se questo oggetto viene creato, deve esserci un costruttore
e quindi questo viene aggiunto automaticamente.
Non riusciamo a trovarlo qui, ma è ancora lì.
Lo vediamo nel codice intelligente.
Quindi sappiamo già più del codice Java.
Super bello.
Possiamo anche vedere che i metodi privati e i costruttori finiscono qui e qui.
Abbiamo i nostri metodi di ritorno.
I metodi virtuali sono metodi pubblici corretti.
E sì, se scorro un po' verso il basso, possiamo vedere che questi metodi virtuali iniziano qui e finiscono
qui, perché non abbiamo un nuovo segno o hashtag.
Ciò significa che abbiamo due metodi pubblici.
Uno stato e uno stato impostato.
Questo e questo.
Bello.
Questa è l'intera struttura dei file per questo file smiley e anche per tutti gli altri file smiley.
Vediamo un altro esempio.
Quindi vediamo cosa abbiamo.
Lo Sprite sembra interessante perché si vede già il segno del dollaro, il che significa che abbiamo
una classe interna o un enum qui.
Diamo un'occhiata.
Ora non stiamo aprendo il codice Java.
Lo facciamo solo nel codice smiley e poi lo confronteremo in seguito.
Quindi posso aumentarlo un po'.
Andiamo.
Va bene.
Vediamo cosa abbiamo.
Alla riga uno, abbiamo class public, il capitale di riferimento della nostra classe.
Questo termina con il punto e virgola qui.
Il nome è Sprite.
Abbiamo una classe chiamata Sprite.
Classe.
Sprite.
E questa classe ha una superclasse.
Quindi abbiamo una sottoclasse di component.
Stiamo estendendo questo componente.
Ok.
Poi abbiamo queste annotazioni, che abbiamo già visto nel codice dello smiley qui.
A questo punto, vediamo cosa abbiamo.
Lo stiamo importando qui ancora una volta.
Ok, poi abbiamo questa classe di membri.
Quindi questa è una classe interna e questa classe interna è denominata livello, può essere una classe interna o anche un tipo
enum.
Possiamo scoprirlo dando un'occhiata al codice degli smiley più avanti.
Per ora, manteniamo questa classe come classe interna.
Quindi diciamo semplicemente che abbiamo
un livello e questo nome di variabile, chiamiamolo anche livello.
Ok, qui abbiamo molti campi di istanza.
E non abbiamo un campo estetico.
Quindi questa classe ha solo campi di istanza e questa ha a, b, g.
Questo nella nostra classe.
E spago.
E questi sono galleggianti.
Alcuni nomi divertenti A, B, G, R e così via.
Queste sono tutte le variabili.
Infine, se si scorre un po' più in basso, abbiamo solo questo metodo diretto, il che significa che abbiamo solo un
costruttore.
Non c'è altro in questa classe qui.
Quindi possiamo vedere il metodo diretto.
Questo è il costruttore.
Quindi questa classe, che si chiama Sprite e che estende questo componente.
Un componente.
Mi dispiace.
Lasciatemi scorrere un po' più in alto.
Questa classe ora ha tutte queste statistiche.
Questo campo di istanza è qui.
Quindi abbiamo un galleggiante, a abbiamo un galleggiante B
e così via.
E non abbiamo alcun metodo, quindi nessun metodo.
Ma nel costruttore abbiamo questo costruttore qui, che inizializza tutti i valori.
Questo, tra l'altro, è molto interessante.
All'inizio sembra davvero ridicolo.
E questo lo scopriremo più avanti.
Si tratta quindi di un numero in virgola mobile.
Il computer non memorizza i numeri in virgola mobile come si potrebbe pensare se non si è mai sentito parlare
di numeri in virgola mobile.
Quindi questo viene memorizzato in un modo davvero interessante.
Abbiamo un pezzo che rappresenta il design.
Se è positivo, negativo, allora abbiamo alcuni bit per la mentazione e poi abbiamo alcuni bit
per l'esponente.
E questo è lo strano valore che si trova qui.
Ma non è necessario saperlo, perché possiamo anche dare un'occhiata a questo e vedere che questa
è la rappresentazione decimale di un numero in virgola mobile.
In questo caso è semplicemente 1. 0.
Ops.
1. 0.
Ok, questo è solo un avviso.
Possiamo anche consultare questa istruzione.
Const hi 16 v zero.
E facciamo una cosa molto veloce.
È un po' fuori tema, ma sì, facciamolo.
Spero quindi che abbiate messo tra i preferiti i vostri codici dalvik up e che mi permettiate di sbarazzarmi di questo.
Quindi stiamo cercando const slash whoops.
Const.
Ciao, 16.
Ecco fatto.
Inserisce la costante a 16 bit nei bit più alti del registro.
Sembra complicato, ma stiamo solo prendendo i 16 bit del valore di queste costanti e li mettiamo nel nostro
registro.
Quindi, se abbiamo un valore rappresentato da 20 bit, non ci interessa.
Prendiamo solo i primi 16 bit e li inseriamo in questo registro.
Quindi perdiamo alcuni valori decimali.
Ok.
Questo è un po' fuori tema, ma se vi capita, non abbiate paura.
Quello che mi piace fare in questo modo è entrare in questo e vedere ock cons hi 16.
Quindi stiamo inserendo sei ingressi nel nostro registro VC e non ci interessa quale sia questo.
Quindi ci sbarazziamo di questo ed ecco fatto.
OC Lo zero è 1. 0 in virgola mobile.
È tutto così semplice.
Va bene.
Ok.
Sì, abbiamo pulito lo schermo un paio di volte, ma comunque torniamo al codice Java, mettiamoli fianco
a fianco e vediamo se è così.
Già.
Avevamo ragione su questo.
Potete tornare indietro nel video se mi sono sbagliato, ma vediamo.
Va bene.
Ora sono fianco a fianco.
E sono anche super interessato a questo perché non l'ho preparato in questo modo.
Mi piace fare queste cose al volo.
Vediamo.
Quindi siamo nella E.
Se Gearbox basso pang.
La vernice di base e poi i componenti e poi i soldi degli sprite.
Sì.
Direi che siamo stati corretti.
Avevamo ragione.
Qui abbiamo solo questi valori.
Abbiamo questo costruttore che manca.
Non abbiamo altri metodi e non abbiamo nemmeno campi statici.
E possiamo anche vedere le nostre, come dire, cose che includiamo qui.
E questo è uno.
Questa classe, la nostra superclasse, viene estesa.
Bello.
Ok, va bene.
A proposito, se siete interessati a questa enum tax, date un'occhiata lì.
Non riusciamo a trovarlo.
Ed è per questo che abbiamo le annotazioni.
Ora possiamo controllare il livello sprite e all'interno del livello sprite dovremmo vedere un riferimento a questi valori.
Effetti predefiniti dello sfondo.
Diamo un'occhiata.
Ecco fatto.
Rendiamolo un po' più grande.
Abilitare nuovamente anche Java.
Eccoci qua.
Quindi, ancora una volta, rifacciamolo.
So che potrebbe essere un po' noioso, ma praticare questo significa imparare queste cose.
E anche se vi limitate a guardare, imparerete qualcosa di nuovo.
Ok.
Non approfondiamo questo aspetto.
Abbiamo il nostro livello di sprite, quindi abbiamo il nostro livello di sprite dollaro nella nostra classe e ora abbiamo queste
annotazioni.
Possiamo vedere che il nostro finale chiuso nella classe è Sprite.
In questo caso, si tratta della nostra classe principale.
E poi abbiamo la nostra classe interna.
Questo ha alcune macchie in eccesso e un nome che è strato.
Non ci interessano le X Flex in questo momento.
Quindi abbiamo il nostro livello di nome.
Quindi abbiamo il livello sprite dollaro.
E poi possiamo vedere, ok, questo è ora di tipo INA.
Se si ha una classe interna e questa viene referenziata qui.
Ok.
E qui possiamo vedere queste etichette.
Così possiamo vedere, ad esempio, la sovrapposizione degli effetti predefiniti dello sfondo di questo attore.
In questo modo possiamo identificare ciò che abbiamo di fronte ed è per questo che abbiamo queste annotazioni nel nostro
file smiley.
Ok.
Ancora una volta, apriamo questo codice Java fianco a fianco.
Andiamo nel nostro livello, il livello sprite.
Questo?
Sì.
E vediamo se riusciamo a vederli.
Attore di sfondo, effetti predefiniti e così via.
Ok.
Non approfondiamo l'argomento perché sarebbe un po' complicato se lo esaminassimo.
Quindi qui si può vedere, ok, questo sembra interessante.
Sono abbastanza sicuro che se procediamo passo dopo passo, riga per riga, saremo in grado di fare il reverse engineering di questa
parte.
Ma non lo stiamo facendo in questo momento.
All'inizio manteniamo le cose semplici e in seguito aumentiamo il ritmo.
Va bene.
Per ora è tutto per questo argomento.
Questo argomento riguardava la struttura di divisione.
Abbiamo visto che cosa significano queste linee, che ci sono separazioni tra i tag hash e che cosa
fa questa annotazione.
Durante il processo di reverse engineering di questo file, abbiamo visto che lo comprendiamo sempre
meglio.
Otteniamo questi riferimenti esterni, li inseriamo nelle nostre classi e abbiamo anche una bella separazione tra campi
di istanza, campi statici, metodi privati e pubblici.
Ok.
Nel prossimo video daremo un'occhiata al nostro file player dot smiley, la versione estesa, e faremo
ancora una volta un processo di reverse engineering su questo file.
E poi faremo un quiz in cui potrete esercitarvi da soli.
E in seguito applicheremo una patch alla nostra applicazione Space Pang, in modo da non poter più perdere questa
partita.
Va bene.
Ci vediamo nel prossimo video.