In molte istruzioni per ottenere i diritti di root e modificare il firmware, è necessario abilitare il debug USB e OEM Factory Unlock. Che cos'è il debug USB? A cosa serve e come abilitarlo, puoi imparare da questo articolo!
A cosa serve il debug USB?
Il debug USB viene utilizzato per utilizzare il servizio di debug dell'applicazione e modificare i parametri dei dispositivi sul sistema operativo Android (controlla come funzionano l'applicazione e il sistema nel suo insieme e quali arresti anomali si sono verificati) utilizzando un'utilità chiamata ADB.
Che cos'è lo sblocco di fabbrica OEM?
A partire da Android 5.0, molti produttori hanno iniziato a introdurre un meccanismo di sicurezza aggiuntivo contro le modifiche non autorizzate alle partizioni di sistema. Di conseguenza, la funzione "OEM Factory Unlock" è stata introdotta nella sezione "Menu sviluppatore", una volta attivata, è possibile eseguire il flashing di ripristino di terze parti e firmware personalizzato.
Non confondere "OEM Factory Unlock" con lo sblocco Bootloader, richiesto da molti produttori: Xiaomi, HTC, Huawei, Google Pixel, Sony.
Menu sviluppatore Android
"USB Debugging" e "OEM Factory Unlock" sono tutti in una sezione nascosta delle impostazioni Android chiamata "Menu sviluppatore". Per vedere questa sezione è necessario eseguire una semplice procedura di attivazione.
Come abilitare il debug USB?
Assolutamente in tutti i dispositivi Android, indipendentemente dal fatto che sia uno smartphone o un tablet, è presente il debug USB Menu -> Impostazioni.
Possibili opzioni per la posizione dell'opzione
Anche se il debug USB è nelle impostazioni, le opzioni di posizione nel menu possono essere diverse e avere diverse opzioni su come trovarlo! Considera 8 possibili opzioni dalle versioni più recenti di Android a quelle precedenti.
Opzione n. 1 per Android 4.2 - Android 7.1:
Menu -> Impostazioni -> Informazioni su smartphone/Informazioni su tablet -> Impostazioni -> Per sviluppatori -> Debug USB- tic tac.
Opzione numero 2.1 per Xiaomi (nuove versioni di MIUI)
Menu -> Impostazioni -> Informazioni su Telefono-> Versione MIUIe fare clic su di esso circa 7 - 10 volte, quindi tornare a Impostazioni -> Avanzate -> Per sviluppatori -> Debug USB- tic tac.
Opzione numero 2.2 per Xiaomi (vecchie versioni di MIUI)
Menu -> Impostazioni -> Generale -> Informazioni su smartphone/Informazioni su tablet ->Numero build e fare clic su di esso circa 7 - 10 volte, quindi tornare a Impostazioni -> Per sviluppatori -> Debug USB- tic tac.
Opzione n. 3 per Android 8.X e versioni successive:
Su Android 8.0 e versioni successive, le impostazioni sono state leggermente aggiornate e ora, per accedere al menu sviluppatore e abilitare il debug USB, è necessario: vai su Sistema -> Informazioni sul dispositivo (tablet/telefono) -> Fai clic 5-7 volte su Numero build" e torna a Sistema -> Menu sviluppatore.
Per le versioni Android 1.6 - 4.2
Opzione numero 4:
Menu -> Impostazioni -> Sviluppo -> Debug USB - spuntare
Opzione numero 5:
Menu -> Impostazioni -> Per sviluppatori -> Debug USB- tic tac
Opzione numero 6:
Menu -> Impostazioni -> Applicazioni ->
Sviluppo -> Debug USB (Android 2.2 - 3.0)
Opzione numero 7:
Menu -> Impostazioni -> Altro -> Opzioni sviluppatore -> Debug USB- tic tac
Opzione n. 8 per Android 4.2 e versioni successive:
Menu -> Impostazioni -> Sistema -> Informazioni sullo smartphone/Informazioni sul tablet -> Numero build e fare clic su di esso circa 7 - 10 volte, quindi tornare a Impostazioni -> Per sviluppatori -> Debug USB- tic tac
[nascondere]
Dopo aver abilitato il debug USB, autorizzazione del computer! (Per Android 4.2 e versioni successive)
Quando ci si connette a un computer per la prima volta e inserendo qualche comando o ottenendo i diritti di root, avrai una richiesta di fiducia computer a cui è attualmente connesso Android! Questa richiesta apparirà su qualsiasi nuovo computer o laptop! Selezionare la casella e premere Pulsante OK.
Debug USB abilitato.
Debug USB abilitato e dispositivo Android
non definito?
Primo quello che devi credere è driver USB installati sul tuo computer o reinstallarli/aggiornarli. Un altro problema, perché Android non è definito - è in stato bloccato! Sbloccare il tuo smartphone o tablet! Non usare una porta USB 3.0 solo USB 2.0
Se non riesci ancora a installare il debug USB con un computer, dovresti provare a cambiare il modo in cui ti connetti a un PC. Nel momento in cui hai già collegato il tuo smartphone o tablet al PC, tira verso il basso la barra informativa superiore "tenda" -> selezionare connessione USB e attiva Modalità PTP.
Se vuoi connetterti via WI-FI
Dopo aver abilitato questa opzione su Android, puoi collegare il tuo smartphone a un PC e inserire i comandi adb necessari o ottenere i diritti di Root!
Hai ancora domande? Scrivili nei commenti, raccontaci cosa hai fatto o viceversa!
È tutto! Leggi altri articoli e istruzioni utili nella sezione. Resta con il sito, sarà ancora più interessante!
Il debug USB consente di utilizzare il servizio di debug per applicazioni e dispositivi su OS Android: controlla come funzionano l'applicazione e il sistema, quali arresti anomali si sono verificati.
Abilita debug USB
In tutti i dispositivi Android, il debug USB si trova in Menu > Impostazioni, ma le opzioni di posizione possono variare, ad esempio:
Menu > Impostazioni > Sviluppo > Menu debug USB (attivo) > Impostazioni > Applicazioni > Sviluppo > Menu debug USB (attivo) > Impostazioni > Altro > Opzioni sviluppatore > Menu debug USB > Impostazioni > Generali > Informazioni sullo smartphone/Informazioni sul tablet > Numero build ( toccalo 7 - 10 volte), quindi torna a Impostazioni > Opzioni sviluppatore > Debug USB (attivo)
Dopo aver abilitato il debug USB
Sblocca il tuo smartphone o tablet. Non utilizzare una porta USB 3.0, solo USB 2.0 durante il collegamento a un computer.
Quando il dispositivo viene connesso al computer per la prima volta, ti verrà chiesto di considerare attendibile il computer: seleziona la casella e fai clic su OK. Debug USB abilitato.
Installazione dell'applicazione di debug USB
Per il debug, utilizzare il programma ADB (Android Debug Bridge - Android debug bridge). ADB fa parte dell'SDK Android, di cui hai bisogno per .
Scarica l'archivio zip dall'SDK di Android, contiene la cartella adt-bundle-windows-x86_64-20140702, che contiene l'SDK stesso. Decomprimilo sul tuo computer. Ad esempio, abbiamo inserito una cartella nella radice dell'unità C, ad es. il percorso dell'SDK sarà: C:\adt-bundle-windows-x86_64-20140702\
Ci assicuriamo che il computer sia connesso a Internet ed eseguiamo il programma SDK Manager che si trova nella cartella adt-bundle-windows-x86_64-20140702.
Se SDK Manager non si avvia, installare Java SE.
Dopo aver avviato il programma SDK Manager, apparirà la finestra di installazione. Dobbiamo scaricare e installare
✓ Strumenti della piattaforma SDK Android ✓ Strumenti SDK Android ✓ Pacchetto driver USB di Google
Contrassegniamo questi tre elementi nell'elenco e deselezioniamo tutti gli altri. Fare clic su "Installa" e attendere che il programma scarichi i componenti.
I driver USB per Windows a 32 e 64 bit verranno scaricati in C:\adt-bundle-windows-x86_64-20140702\extras\google\usb_driver (installarli in seguito se non trovi i driver ufficiali per il tuo tablet o smartphone).
Colleghiamo il nostro dispositivo al computer: il computer rileverà nuove apparecchiature. Installare i driver dal sito Web del produttore o dalla cartella in cui sono stati scaricati in precedenza (l'installazione viene eseguita tramite Task Manager> *Dispositivo sconosciuto*> tasto destro del mouse> Aggiorna software driver ..> cerca un driver sul PC> driver scaricati ).
Dopo aver installato i driver, in Gestione dispositivi apparirà un nuovo dispositivo "Interfaccia ADB".
Se il dispositivo non viene rilevato nel gestore come Interfaccia ADB, controllare i driver del tablet o dello smartphone, spegnere e attivare la modalità debug USB, ricollegare il dispositivo al PC.
Avvio del programma adb
Il modo migliore per lavorare con il programma ADB è tramite la riga di comando di Windows. Per chiamare la riga di comando, fai clic su "Start" e nel campo di input "Cerca programmi e file" digita cmd, premi "Invio".
Per vedere quali dispositivi sono collegati al computer, digitiamo il comando:
C:\adt-bundle-windows-x86_64-20140702\sdk\platform-tools\adb.exe dispositivi
Il programma ADB visualizzerà un elenco di dispositivi attualmente collegati al computer. Se il dispositivo viene visualizzato sulla riga di comando, è possibile avviare il debug.
Debug di i2 Control V2.2 tramite USB
Inserisci (1):
C:\adt-bundle-windows-x86_64-20140702\sdk\platform-tools\adb.exe logcat
La riga di comando inizierà a visualizzare il registro del tuo smartphone o tablet.
Interrompere il registro facendo clic ctrl+c
Inserisci (2):
C:\adt-bundle-windows-x86_64-20140702\sdk\platform-tools\adb.exe logcat >log.txt
Ora il registro riavviato con (1) verrà salvato in un file di testo che si trova in C:\Utenti\*Nome utente*\log.txt
Eseguire l'applicazione i2 Control V2.2 sul tablet o smartphone, eseguire il registro (1), eseguire l'azione che si desidera salvare il registro, interrompere la registrazione premendo Ctrl+C.
Puoi inviare il log salvato al supporto tecnico, accompagnandolo con il tuo progetto, descrizione del problema, modello e versione firmware del tablet o smartphone su cui è stato rilevato il problema.
Questo articolo ti mostrerà come collegare un debugger a un'applicazione Android e illustrerà i metodi che vengono chiamati utilizzando le informazioni ottenute dopo la decompilazione dell'applicazione.
Questo articolo ti mostrerà come collegare un debugger a un'applicazione Android e illustrerà i metodi che vengono chiamati utilizzando le informazioni ottenute dopo la decompilazione dell'applicazione. La buona notizia è che il debug non richiede privilegi di superutente. Le tecniche descritte possono essere molto utili durante i test di penetrazione delle applicazioni mobili, poiché possiamo "penetrare" il codice mentre il programma è in esecuzione, ottenere e registrare informazioni a cui di solito non abbiamo accesso. Ad esempio, puoi intercettare il traffico prima della crittografia e ottenere chiavi, password e qualsiasi altra informazione preziosa al volo. L'articolo sarà utile per i pentester e gli sviluppatori di applicazioni mobili che desiderano approfondire le conoscenze sui possibili attacchi alla piattaforma Android.
Requisiti dell'ambiente di prova:
- Sistema operativo: Windows/Mac OS X/Linux
- Java (versione 1.7 consigliata)
- IDE (Eclipse, IntelliJ IDEA, Android Studio)
- SDK Android (https://developer.android.com/sdk/index.html?hl=i)
- APKTool (https://code.google.com/p/android-apktool/)/APK Studio (http://apkstudio.codeplex.com)
- Dispositivo/emulatore Android
Questo articolo utilizzerà la configurazione seguente: Windows 8, Android Studio e IntelliJ IDEA. Dispositivo: Nexus 4 con versione Android 4.4.4. Consiglio di aggiungere tutte le utilità alla variabile di ambiente PATH per facilitare e velocizzare l'accesso a questi strumenti.
Il pacchetto dell'applicazione Android (APK) utilizzato in questo articolo può essere scaricato da qui: com.netspi.egruber.test.apk .
Configurazione del dispositivo
Le istruzioni seguenti ti aiuteranno a preparare il dispositivo per gli esperimenti.
Attivazione della sezione Opzioni sviluppatore
Per cominciare, sul dispositivo Android deve essere abilitato il debug via USB (opzione di debug USB), che consentirà di "comunicare" con il dispositivo utilizzando gli strumenti dell'SDK Android. Tuttavia, prima di ciò, devi attivare la sezione Opzioni sviluppatore. Sul dispositivo, vai nella sezione Impostazioni > Informazioni sul telefono e clicca più volte sulla voce Build Number, dopodiché dovrebbe apparire un messaggio che indica che la sezione Opzioni sviluppatore è attivata.
Figura 1: per attivare la sezione Opzioni sviluppatore, è necessario fare clic più volte sul numero di build
Abilita il debug tramite USB
Per abilitare il debug USB, vai su Impostazioni > Opzioni sviluppatore e seleziona la casella accanto a Debug USB.
Figura 2: abilitazione dell'opzione di debug USB
Collegamento del dispositivo ed esecuzione di ADB
Dopo aver collegato il dispositivo al computer tramite la porta USB, dovrebbe apparire il messaggio "Debug USB connesso sul dispositivo". Dovresti anche verificare se puoi connetterti al dispositivo utilizzando l'app Android Debug Bridge (ADB) inclusa con l'SDK Android (pacchetto di strumenti della piattaforma SDK Android). Al prompt dei comandi, immettere il seguente comando:
Il dispositivo dovrebbe apparire nell'elenco.
Figura 3: Elenco dei dispositivi collegati
Se il dispositivo non viene visualizzato nell'elenco, la causa più probabile sono i driver installati in modo errato (in Windows). A seconda del dispositivo, il driver può essere trovato nell'SDK Android o sul sito Web del produttore.
Controllo dell'applicazione per il debug
Prima di eseguire il debug delle applicazioni Android, devi prima verificare se ciò è possibile. La verifica può essere eseguita in diversi modi.
Il primo modo è correre Monitor del dispositivo Android, che fa parte dell'SDK di Android (nella cartella degli strumenti). In Windows, il file si chiama monitor.bat. Quando apri Android Device Monitor, il dispositivo apparirà in Dispositivi.
Figura 4: Applicazione di monitoraggio del dispositivo Android
Se è possibile eseguire il debug di qualsiasi applicazione sul dispositivo, anche tale applicazione verrà visualizzata nell'elenco. Ho creato un programma di test, ma l'elenco è vuoto perché non è possibile eseguire il debug del programma.
Il secondo modo per testare l'applicazione per il debug è esaminare il file AndroidManifest.xml dal pacchetto dell'applicazione (APK, pacchetto dell'applicazione Android). Un APK è un archivio zip contenente tutte le informazioni necessarie per eseguire un'app su un dispositivo Android.
Ogni volta che un'app viene scaricata dal Google Play Store, viene scaricato anche l'app bundle. Tutti i file APK scaricati vengono generalmente archiviati sul dispositivo nella cartella /data/app. Se non disponi dei diritti di superutente, non sarai in grado di ottenere un elenco di file dalla directory /data/app. Tuttavia, se conosci il nome del file APK, puoi copiarlo utilizzando l'utilità adb. Per conoscere il nome del file APK, inserisci il seguente comando:
Verrà visualizzata la riga di comando del dispositivo. Quindi inserisci il seguente comando:
pm lista pacchetti -f
Verrà visualizzato un elenco di tutti i pacchetti sul dispositivo.
Figura 5: elenco dei pacchetti sul dispositivo
Guardando l'elenco, troviamo un'applicazione di prova.
Figura 6: Pacchetto dell'applicazione di prova creata (evidenziata in bianco)
Ora devi copiare il file del pacchetto. Apri una shell e inserisci il seguente comando:
adb pull /data/app/[file .apk]
Figura 7: copia il file APK dal dispositivo al sistema
Ora dobbiamo aprire il file del pacchetto ed esaminare il contenuto di AndroidManifest.xml. Sfortunatamente, non possiamo semplicemente decomprimere l'archivio perché il file APK è codificato in formato binario. Per la decodifica, l'utilità più comunemente usata è strumento apk anche se sto usando APK Studio perché questa applicazione ha una GUI amichevole. Il resto dell'articolo parlerà di APK Studio.
In APK Studio, fai clic sulla piccola icona verde, assegna un nome al progetto e specifica il percorso del file APK. Quindi specificare un percorso per salvare il progetto.
Figura 8: creazione di un nuovo progetto in APK Studio
Dopo aver aperto l'APK, seleziona il file AndroidManifest.xml e guarda le impostazioni per il tag dell'applicazione. Se il flag android:debuggable non è presente (o presente ma è impostato su false), non è possibile eseguire il debug dell'applicazione.
Figura 9: contenuto del file AndroidManifest.xml
Modifica del file AndroidManifest.xml
Utilizzando l'utilità apktool o APK Studio, possiamo modificare i file e ricomprimere i contenuti in un pacchetto. Ora modificheremo il file AndroidManifest.xml in modo che l'applicazione possa essere sottoposta a debug. Aggiungi la riga android:debuggable="true" all'interno del tag dell'applicazione.
Figura 10: modifica del contenuto del tag dell'applicazione
Dopo aver aggiunto la bandiera, clicca sull'icona "martello" e rimonta il pacco. Il pacchetto ricostruito sarà nella directory build/apk.
Figura 11: Ricostruzione del pacchetto completata con successo
Dopo la ricostruzione, il pacchetto viene firmato e può essere reinstallato sul dispositivo (tutte le applicazioni Android devono essere firmate). La maggior parte delle applicazioni non verifica il certificato utilizzato per la firma. In caso contrario, è necessario modificare il codice che esegue questo controllo.
Ora devi installare il pacchetto ricostruito. Innanzitutto, rimuovi la vecchia applicazione con il seguente comando:
disinstallazione adb pm
Quindi installa il nuovo pacchetto:
adb install [file .apk]
Puoi anche rimuovere e installare un pacchetto con un comando:
adb install -r [file .apk]
Figura 12: Installazione del pacchetto ricostruito
Verificare che l'applicazione reinstallata funzioni correttamente sul dispositivo. Se tutto funziona, torna al Monitor del dispositivo Android, dove dovrebbe apparire l'applicazione di test.
Figura 13: ora è possibile eseguire il debug dell'applicazione ricostruita
Configurazione dell'ambiente di sviluppo (IDE)
Ora puoi agganciare un debugger all'applicazione ricostruita, ma prima devi creare un progetto nell'ambiente di sviluppo (questo articolo usa IntelliJ IDEA). Creiamo un nuovo progetto. Specificare un nome arbitrario nel campo Nome applicazione. Nel campo Nome pacchetto, specificare un nome che corrisponda esattamente alla gerarchia di cartelle del pacchetto ricostruito.
Figura 14: Creazione di un nuovo progetto in IntelliJ IDEA
Di solito il nome del file APK corrisponde alla struttura delle cartelle, anche se se non sei sicuro, in APK Studio controlla la gerarchia delle directory fino alla cartella in cui si trovano i file dell'applicazione. Nel mio caso, il nome e la struttura delle cartelle sono esattamente gli stessi (com.netspi.egruber.test).
Figura 15: Testare la gerarchia delle directory dell'applicazione
Deseleziona "Crea attività Hello World" e termina la creazione del progetto (tutte le altre opzioni rimangono predefinite). Il nuovo progetto dovrebbe assomigliare a questo:
Figura 16: Gerarchia di cartelle e file del nuovo progetto
Dopo aver creato il progetto, è necessario aggiungere il codice sorgente dal file APK in modo che il debugger "conosca" i nomi di simboli, metodi, variabili, ecc. La buona notizia è che le applicazioni Android possono essere decompilate quasi senza perdita di qualità ( il codice sorgente corrisponderà all'originale). Dopo la decompilazione, il codice sorgente viene importato nell'ambiente di sviluppo (IDE).
Ottenere fonti da un pacchetto di applicazioni
Per prima cosa devi convertire l'APK in un file jar. Quindi, usando il decompilatore java, otterremo il codice sorgente dell'applicazione. Effettueremo la conversione in jar usando l'utilità dex2jar. dex2jar ha un file d2j-dex2jar.bat utilizzato per convertire APK in jar. La sintassi del comando è abbastanza semplice:
d2j-dex2jar.bat [file .apk]
Figura 17: Conversione dell'APK in jar
Quindi apriamo o trasciniamo il file risultante nella JD-GUI (questo è un decompilatore java).
Figura 18: Struttura del file jar
Il file jar dovrebbe essere visualizzato come una struttura gerarchica, all'interno della quale sono presenti file java con codice sorgente leggibile. Vai a File> Salva tutte le fonti per comprimere tutte le fonti in un archivio zip.
Figura 19: salvataggio dei sorgenti del file decompilato
Dopo aver salvato i testi di origine, decomprimere l'archivio in una directory separata.
Figura 20: archivio spacchettato
Ora devi importare entrambe le directory nel progetto creato in precedenza nell'IDE. In IntelliJ, vai alla cartella src e copia lì il contenuto dell'archivio decompresso (due directory).
Figura 21: entrambe le cartelle copiate nella directory src
Tornando a Intellij, vediamo il progetto aggiornato.
Figura 22: nel progetto sono comparsi i testi di partenza
Se facciamo clic su qualsiasi elemento dell'elenco, vedremo il testo originale. Come puoi vedere nello screenshot qui sotto (codice sorgente della classe LoginActivity), il codice sorgente è stato offuscato usando ProGuard.
Figura 23: codice sorgente offuscato per la classe LoginActivity
Collegamento di un debugger
Ora che il progetto ha il codice sorgente, possiamo iniziare a impostare punti di interruzione su metodi e variabili. Quando vengono raggiunti i punti di interruzione, l'applicazione si interrompe. Ad esempio, ho impostato un punto di interruzione sul metodo (proprio nel codice offuscato) responsabile dell'elaborazione delle informazioni inserite nel campo di testo.
Figura 24: impostare un punto di interruzione su un metodo offuscato
Non appena viene visualizzato il punto di interruzione, colleghiamo il debugger al processo sul dispositivo facendo clic sull'icona con lo schermo nell'angolo in alto a destra (l'icona potrebbe differire sul tuo IDE).
Figura 25: collegamento di un debugger a un processo
Figura 26: elenco dei processi per collegare un debugger
Dopo aver selezionato un processo, il debugger si connetterà al dispositivo.
Figura 27: debugger collegato a un processo in esecuzione sul dispositivo
Nel campo di testo inserirò il numero 42 (se ricordi, c'è un punto di interruzione sul metodo corrispondente).
Figura 28: Immettere il numero 42 nel campo di testo
Dopo aver premuto il pulsante "Inserisci codice", l'esecuzione dell'applicazione si interromperà al punto di interruzione, poiché il debugger è "a conoscenza" di quale metodo viene chiamato sul dispositivo. Un'applicazione Android compilata contiene informazioni di debug (come i nomi delle variabili) disponibili per qualsiasi debugger conforme JDWP (Java Debug Wire Protocol). Se il debug è abilitato nell'applicazione, un debugger compatibile con JDWP (la maggior parte dei debugger forniti con gli ambienti di sviluppo Java rientrano in questa categoria) sarà in grado di connettersi alla macchina virtuale dell'applicazione Android e quindi leggere ed eseguire i comandi di debug.
Figura 29: punto di interruzione raggiunto
Lo screenshot qui sotto mostra il numero che abbiamo precedentemente inserito nel campo di testo.
Figura 30: Elenco delle variabili dell'istanza corrente della classe
Conclusione
Non solo possiamo leggere i dati nell'applicazione, ma anche inserirne di nostri. Questo può essere utile se, ad esempio, vogliamo interrompere il flusso di esecuzione del codice e bypassare alcune parti dell'algoritmo. Con l'aiuto di un debugger, possiamo comprendere meglio la logica dell'applicazione e analizzare ciò che non è disponibile per un utente normale. Ad esempio, può essere molto utile visualizzare le funzioni di crittografia utilizzate e le chiavi dinamiche. Inoltre, a volte durante il debug è utile sapere come le funzioni interagiscono con il file system o il database per capire quali informazioni sono memorizzate dall'applicazione. Tali manipolazioni sono disponibili su qualsiasi dispositivo Android senza privilegi di superutente.
Buon pomeriggio. Capita spesso che dobbiamo controllare il nostro dispositivo con il sistema operativo Android utilizzando un computer. Che si tratti di test generali o di diagnostica di routine, per identificare eventuali carenze. Per fare ciò, è necessario abilitare la cosiddetta modalità "Debug USB". Non importa quanto possa sembrare intimidatorio, in realtà è molto semplice e accessibile non solo ai guru dei gadget, ma anche all'abilità del principiante più ordinario. Che cos'è il debug USB di Android, come abilitare questo debug USB tramite PC sul tuo Android, possiamo imparare dal nostro articolo.
Diciamo subito che la connessione al nostro personal computer è molto più preferibile che lavorare con un emulatore di PC.
Per ogni vigile del fuoco inseriamo una piccola istruzione video su come impostare il “debug USB”, ma poco più in basso parleremo più nel dettaglio di tutti i metodi e le regole di questa procedura.
Cosa deve essere fatto e in quale ordine
Nella maggior parte dei casi, la modalità di debug USB di cui abbiamo bisogno, per tutti i produttori, può essere trovata e impostata tramite il menu "Impostazioni". Di solito contiene il sottomenu "Sviluppo" o "Per sviluppatori". E anche se non siamo sviluppatori, troviamo ancora audacemente il "debug USB" desiderato lì e, senza ulteriori indugi, ci mettiamo un po' di tempo.
Potresti pensare che questo è il punto in cui tutte le nostre prove sono finite, ma non era lì. È possibile che non ci sia tale opzione nel tuo menu. Ecco quei tempi. Questo non è più per me, ma per i veri sviluppatori. Perché l'hanno fatto? Non chiaro. Forse non tutti potrebbero frugare nel dispositivo e rompere la legna da ardere lì.
Il modo più semplice per abilitare il debug USB
Se non ce n'è nel nostro menu, proveremo ad andare dall'altra parte. Diverse varietà per ottenere il debug USB su diversi sistemi operativi Android. Se hai Android 2.2 3.0, allora proviamo ad entrare prima nello stesso “Menu”, poi in Impostazioni, poi in “Applicazioni”, poi in “Sviluppo”. È possibile che sia già presente una voce "Debug via USB".
Per tutti i possessori di Android 4.2 e versioni successive, è stato inventato il seguente percorso molto complicato. Di nuovo andiamo al "Menu", quindi a "Impostazioni", a "Informazioni sullo smartphone / Informazioni sul tablet". Troviamo qui "Numero build » e faremo delle azioni sciamaniche. Facciamo clic su di esso 8-10 volte e quando entriamo in "Impostazioni", in modo incomprensibile, appaiono improvvisamente "Per sviluppatori" e "Debugging tramite USB". Resta solo da mettere di nuovo un daw.
Daremo per scontato che ci siamo riusciti e che questo debug è abilitato. La prima volta che ci si connette al nostro PC o si immette un comando, ci sarà una richiesta di fiducia nel computer attualmente connesso. Quindi ci fidiamo completamente del nostro computer, quindi mettiamo un segno di spunta, fai clic su "OK". Qualunque cosa. Debug abilitato. Se improvvisamente il computer non vuole rilevare il nostro dispositivo, prova quanto segue. Controlla se il tuo smartphone/tablet è improvvisamente bloccato. Sbloccalo, controlla di nuovo il debug.
Se ancora non funziona, prova ad aggiornare/sostituire/reinstallare i driver USB sul tuo PC. Nota: si consiglia di utilizzare solo una porta USB 2.0 e non una porta USB 3.0. Tuttavia, oso essere sicuro che tutto abbia funzionato per te e che la modalità di configurazione USB sia attivata.
Vieni a trovarci più spesso!
Modalità " Debug USB” si trova sempre nel menu delle impostazioni dello smartphone, indipendentemente dalla marca del dispositivo o dalla versione del sistema operativo. Tuttavia, vale la pena notare che il percorso finale attraverso il quale è possibile accedere a questa modalità potrebbe differire. E se decidi tu abilita il debug USB, quindi probabilmente stai provando o qualche programma lo richiede, ad esempio, per recuperare file cancellati su Android.
Opzione uno (rilevante per la maggior parte delle versioni del sistema operativo Android).
Per prima cosa devi accedere al menu delle impostazioni. Successivamente, nei paragrafi inferiori, trova "Sviluppo" e seleziona la casella "Debug tramite USB". 
Opzione due (rilevante per la maggior parte dei tablet)
Qui, l'algoritmo delle azioni è identico alla prima opzione, ad eccezione della voce "Sviluppo". Nelle versioni del sistema operativo Android precedenti alla 2.2, questo elemento è chiamato "For Developers".
Dopo aver scritto la prima versione del codice del nostro programma, ovviamente, vogliamo eseguirlo e testarlo per rilevare potenziali problemi (o semplicemente per metterci in mostra). Ci sono due modi per farlo: eseguire l'applicazione su un dispositivo reale collegato al computer con un cavo USB; chiamare l'emulatore incluso nell'SDK e testare l'applicazione su di esso.
In entrambi i casi, dobbiamo eseguire alcune azioni per vedere il nostro programma in azione.
Connessione del dispositivo
Prima di collegare un dispositivo per il test, è necessario assicurarsi che sia riconosciuto dal sistema operativo. Su Windows, ciò richiede l'installazione del driver appropriato, che fa parte dell'installazione dell'SDK che abbiamo installato in precedenza. Basta collegare il dispositivo e seguire le istruzioni per installare il driver standard di Windows, puntando alla cartella driver/ nella directory di installazione dell'SDK. I driver per alcuni dispositivi dovranno essere scaricati dal sito Web dei rispettivi produttori. Su Linux e Mac OS X, di solito non è necessario installare i driver separatamente: vengono forniti con il sistema operativo. A seconda della versione di Linux in uso, potrebbe essere necessario eseguire alcuni passaggi aggiuntivi (di solito per creare un nuovo file di regole udev). Per dispositivi diversi, l'insieme di azioni può variare: la ricerca sul Web ti aiuterà.
Crea un dispositivo virtuale Android
L'SDK viene fornito con un emulatore che esegue i cosiddetti dispositivi virtuali Android (AVD). Questo dispositivo virtuale è costituito da un'immagine di una determinata versione del sistema operativo Android, una skin e una serie di attributi tra cui risoluzione dello schermo, dimensioni della scheda di memoria, ecc. Per creare un nuovo AVD, è necessario eseguire l'SDK e il gestore AVD . Puoi farlo come descritto nelle istruzioni di installazione dell'SDK o direttamente in Eclipse facendo clic sul pulsante Gestione SDK sulla barra degli strumenti.
1. Selezionare Dispositivi virtuali dall'elenco sul lato sinistro. Di conseguenza, vedrai un elenco di dispositivi virtuali disponibili. Se non hai mai utilizzato il gestore SDK prima, questo elenco sarà vuoto; Cambiamo questo stato di cose.
2. Per creare un nuovo AVD, fare clic sul pulsante Nuovo sul lato destro. Apparirà una finestra di dialogo (Fig. 2.7).
Riso. 2.7. Finestra di dialogo per la creazione di AVD nel gestore SDK
3. Ogni dispositivo virtuale ha un nome (campo Nome) con il quale in seguito ti riferirai ad esso. La destinazione definisce la versione di Android che l'AVD dovrebbe utilizzare. È inoltre possibile definire le dimensioni della scheda di memoria per l'AVD e la risoluzione dello schermo. Per il nostro semplice progetto hel1o world, possiamo selezionare Android 1.5 come target, lasciando invariato il resto dei parametri. In un ambiente di test reale, in genere è necessario creare più dispositivi virtuali per testare l'applicazione per diverse versioni del sistema operativo e dimensioni di visualizzazione.
NOTA
Se non disponi di veri dispositivi Android di versioni diverse e con schermi diversi, è più conveniente utilizzare un emulatore per ulteriori test di compatibilità delle applicazioni.
Lancio dell'applicazione
Ora che hai configurato i dispositivi e gli AVD, puoi finalmente eseguire la tua applicazione. In Eclipse, ciò avviene semplicemente facendo clic con il pulsante destro del mouse sul progetto heloworl d nella vista Package Explorer e selezionando Esegui come applicazione Android (o facendo clic sul pulsante Esegui sulla barra degli strumenti). Di conseguenza, l'ambiente eseguirà le seguenti azioni in background.
1. Compila il progetto in un file APK (se sono state apportate modifiche ai file dall'ultima compilazione).
2. Crea una nuova configurazione di avvio per il progetto Android se non esiste già (parleremo presto della configurazione di avvio).
3. Installa e avvia l'applicazione avviandone una nuova o utilizzando un emulatore già in esecuzione della versione Android appropriata, oppure distribuendola ed eseguendola su un dispositivo connesso (che ha anche una versione del sistema operativo non inferiore a quella specificata dalla versione Min SDK impostazione durante la creazione del progetto).
Se hai appena creato un AVD per Android 1.5 (come descritto sopra), il plug-in ADT per Eclipse avvierà una nuova istanza dell'emulatore, distribuirà l'APK del progetto hello world ed eseguirà l'applicazione. All'uscita, vedrai qualcosa di simile alla Fig. 2.8.
L'emulatore funziona quasi esattamente come un dispositivo reale e puoi interagire con esso con il mouse come se stessi usando il dito. Tuttavia, ci sono diverse differenze rispetto al lavoro con un dispositivo reale.
L'emulatore non supporta il multitouch. Sposta il puntatore del mouse e immagina che sia un dito. Nell'emulatore mancano alcune applicazioni (ad esempio, Android Market).
È inutile scuotere il monitor per cambiare l'orientamento dello schermo. Utilizzare invece il tasto 7 sul tastierino numerico opzionale per ruotare il display. Per non comporre invece il numero 7, devi prima premere Bloc Num.
Riso. 2.8. Fantastica app Hello World in azione.
L'emulatore è molto, molto lento. Non giudicare le prestazioni della tua app dalla velocità con cui viene eseguita sull'emulatore.
Al momento della scrittura, l'emulatore supporta solo OpenGL ES 1.0 con alcune estensioni. Per i nostri scopi, questo è sufficiente (tranne che l'implementazione della libreria grafica sull'emulatore soffre di errori e talvolta potresti non ottenere gli stessi risultati di un dispositivo reale). Per ora, ricorda solo di non testare le applicazioni che utilizzano OpenGL ES su un emulatore.
Prova diverse azioni con l'emulatore per abituarti.
NOTA
L'avvio di una nuova istanza richiede una notevole quantità di tempo (fino a diversi minuti, a seconda delle caratteristiche della workstation). Per risparmiare tempo, mantieni l'emulatore in esecuzione durante la sessione di sviluppo senza riavviarlo ogni volta.
A volte, quando si avvia un'applicazione Android, la selezione automatica dell'emulatore/dispositivo eseguita dal plug-in ADT diventa un ostacolo. Ad esempio, abbiamo collegato diversi dispositivi o emulatori e vogliamo testare il progetto su uno di essi. Per ottenere ciò, puoi disabilitare la selezione automatica dell'emulatore/dispositivo nella configurazione di esecuzione del progetto Android. A proposito, qual è la configurazione di avvio?
La configurazione di avvio fornisce un modo per dire a Eclipse esattamente come dovrebbe avviare l'applicazione ricevendo il comando appropriato. Questo di solito si traduce nella capacità di definire gli argomenti della riga di comando passati al programma, gli argomenti della macchina virtuale (nel caso delle applicazioni desktop Java SE), ecc. Eclipse e plug-in di terze parti offrono diverse configurazioni di avvio per determinati tipi di progetto. ADT non fa eccezione: aggiunge anche la propria configurazione di avvio al set. Quando abbiamo lanciato la nostra applicazione per la prima volta, Eclipse e ADT hanno creato una nuova configurazione Android Application Run con opzioni predefinite.
Per accedere alla configurazione di esecuzione del tuo progetto, segui questi passaggi.
1. Fare clic con il pulsante destro del mouse sul progetto nella vista Package Explorer e selezionare Esegui come - Esegui configurazioni.
2. Seleziona il progetto Hello World dall'elenco a sinistra.
3. Sul lato destro della finestra, è possibile modificare il nome della configurazione di avvio, nonché regolare altre impostazioni nelle schede Android, Target (Target) e Commons (schede Generali).
4. Per passare dalla distribuzione da automatica a manuale, vai alla scheda Destinazione e seleziona Manuale.
Ora, quando avvii l'applicazione, ti verrà chiesto di selezionare l'emulatore o il dispositivo appropriato da distribuire. Questa finestra di dialogo è mostrata in Fig. 2.9. Per chiarezza, ho aggiunto diversi dispositivi virtuali con diverse versioni del sistema operativo di destinazione e ho anche collegato due dispositivi reali.
Riso. 2.9. Selezione di un emulatore/dispositivo per eseguire l'applicazione
La finestra di dialogo mostra tutti gli emulatori in esecuzione e i dispositivi attualmente collegati, nonché altri AVD non attualmente in esecuzione.
Debug dell'applicazione
A volte l'applicazione si comporta in modo imprevisto o smette di funzionare. Per determinare la causa del problema, è necessaria la possibilità di eseguire il debug del programma. Eclipse e ADT offrono funzionalità incredibilmente potenti per le applicazioni Android. Possiamo impostare punti di interruzione nel codice, ottenere i valori delle variabili, ottenere lo stato corrente dello stack e molto altro.
Prima di poter iniziare a utilizzare il debug, devi correggere il file AndroidManifest.xml. Questo punto è una specie di problema di gallina e uova poiché non abbiamo mai esaminato i file manifest prima. Per ora ci basta sapere che il file manifest definisce alcuni degli attributi della nostra applicazione. Uno di questi è la capacità di eseguire il debug dell'applicazione. Questo parametro è specificato sotto forma di attributo XML del tag
Durante lo sviluppo dell'applicazione, puoi lasciare questo attributo nel file manifest. Tuttavia, assicurati di rimuoverlo prima di inviare il pacchetto all'Android Market.
Ora che hai abilitato il debug per la tua applicazione, puoi implementarlo su un emulatore o dispositivo. Questo è solitamente espresso nell'impostazione di punti di interruzione per analizzare lo stato del programma in determinate fasi. Per impostare un punto di interruzione, apri il file di codice in Eclipse e fai doppio clic nell'area grigia prima della riga di codice desiderata. Per dimostrare questa possibilità, lo faremo nella riga 23 della classe He1oWorl dActi vi ty. Ciò farà sì che il debugger arresti l'avanzamento del programma ogni volta che viene premuto il pulsante sullo schermo. Il punto di interruzione è contrassegnato nell'editor di codice con un piccolo cerchio davanti alla riga in cui è stato impostato (Figura 2.10). Per rimuovere un punto di interruzione, fare nuovamente doppio clic su di esso nell'editor di codice.
Riso. 2.10. Impostazione di un punto di interruzione
L'avvio del debug è molto simile al processo di avvio dell'applicazione descritto sopra. Fare clic con il pulsante destro del mouse sul progetto nella vista Package Explorer e selezionare Debug come - Applicazione Android (Debug - Applicazione Android). In questo modo creerai una nuova configurazione di debug per il tuo progetto (proprio come hai fatto quando hai appena avviato il programma). È possibile modificare le impostazioni predefinite per questa configurazione selezionando Debug As - Debug Configurations dal menu contestuale.
NOTA
Invece di utilizzare il menu di scelta rapida del progetto nella visualizzazione Package Explorer, è possibile utilizzare il menu Esegui per eseguire ed eseguire il debug dell'applicazione e accedere alle impostazioni.
Se stai avviando una sessione di debug per la prima volta, Eclipse ti chiederà se desideri passare alla prospettiva Debug, cosa che puoi fare senza esitazione. Consideriamo questa prospettiva. Sulla fig. La Figura 2.11 mostra come appare dopo aver avviato il processo di debug della nostra applicazione helo world.
Riso. 2.11. Prospettiva di debug
Se ricordi la nostra breve panoramica di Eclipse, allora sai che ci sono diverse prospettive in esso, costituite da una serie di viste per attività specifiche. La prospettiva Debug appare molto diversa dalla prospettiva Esegui.
La prima delle nuove viste da guardare è Debug nell'angolo in alto a sinistra. Mostra tutte le applicazioni attualmente in esecuzione e gli stack di tutti i loro thread se sono in esecuzione in modalità di debug.
Sotto la vista Debug c'è la vista di modifica del codice che abbiamo già visto nella prospettiva Java.
La vista Console mostra i messaggi del plug-in ADT che ci informano su cosa sta succedendo.
La vista LogCat diventerà uno dei nostri migliori amici durante lo sviluppo di applicazioni. Mostra un registro dei messaggi provenienti da componenti di sistema, altre applicazioni e dal nostro programma. Mostra anche la traccia dello stack se l'applicazione si arresta in modo anomalo e i nostri messaggi in tempo reale. LogCat sarà trattato in modo più dettagliato nella prossima sezione.
Rappresentazione Outline (Contour) non è molto utile in questa prospettiva. Molto probabilmente studierai variabili e punti di interruzione e la posizione attuale nel programma non ti sarà di alcuna utilità. Di solito chiudo questa vista dalla prospettiva Debug per lasciare più spazio agli altri.
La vista Variabili è particolarmente utile per scopi di debug. Quando il debugger raggiunge un punto di interruzione, abbiamo l'opportunità di esaminare e modificare le variabili nel contesto del programma corrente.
Infine, la vista Punti di interruzione mostra l'elenco dei punti di interruzione che abbiamo impostato.
Se sei curioso, probabilmente hai già premuto un pulsante in un'applicazione in esecuzione per vedere il debugger in azione. Si fermerà alla riga 23 in base al punto di interruzione impostato. Si può anche notare che nella vista Variabili sono apparse le variabili del blocco corrente del programma, costituite dall'attività stessa (this) e dal parametro del metodo (v). Espandendo l'elenco delle variabili, puoi esplorarle in modo più dettagliato.
La visualizzazione Debug mostra la traccia dello stack relativa al metodo corrente. Tieni presente che puoi avere più thread in esecuzione, ognuno dei quali puoi sospendere in qualsiasi momento nella visualizzazione Debug. Viene evidenziata la riga dove è impostato il breakpoint, indicando la posizione nel codice del programma.
Puoi dire al debugger di eseguire l'istruzione corrente (premendo F6), entrare nei metodi chiamati dal metodo corrente (premendo F5) o continuare a eseguire il programma normalmente (premendo F8). Puoi anche raggiungere gli stessi obiettivi usando il menu Esegui. Tieni presente che in realtà ci sono più opzioni di debug di quelle che ti ho appena detto. Come sempre, ti suggerisco di sperimentare di persona ciò di cui hai bisogno.
NOTA
La curiosità è l'elemento fondamentale per lo sviluppo di giochi Android di successo. Devi acquisire familiarità con l'ambiente di sviluppo per ottenere il massimo da esso. e non posso descrivere tutti i dettagli di Eclipse, quindi ancora una volta ti incoraggio a sperimentare.
Logcat e DDMS
Il plug-in ADT installa molte nuove viste e prospettive da utilizzare in Eclipse. Una delle viste più utili (menzionata di sfuggita nella sezione precedente) si chiama LogCat.
LogCat è un sistema di registrazione degli eventi Android che consente ai componenti e alle applicazioni del sistema di emettere informazioni a vari livelli. Ciascuna voce di registro è costituita da data, ora, livello di registro, ID processo dell'origine della voce, un tag (definito dall'applicazione stessa) e il messaggio stesso.
La vista LogCat raccoglie e visualizza queste informazioni da un emulatore connesso o da un dispositivo reale. Sulla fig. La Figura 2.12 mostra un output di esempio nella vista LogCat.
Riso. 2.12. Vista Logcat
Presta attenzione ai pulsanti nell'angolo in alto a destra di LogCat.
I primi cinque ti consentono di selezionare i livelli di registrazione che desideri visualizzare.
Il pulsante più verde consente di definire un filtro in base a tag, ID processo, livello di registrazione. Ti aiuterà molto se vuoi solo vedere il log della tua applicazione (che probabilmente utilizzerà un tag specifico).
I pulsanti rimanenti consentono di modificare e cambiare il filtro, nonché di cancellare la finestra di output.
Se più dispositivi/emulatori sono collegati contemporaneamente, LogCat visualizzerà le informazioni solo da uno di essi. Per informazioni più dettagliate, è possibile utilizzare la prospettiva DDMS.
DDMS (Dalvik Debugging Monitor Server) offre informazioni più dettagliate sui processi Dalvik e le macchine virtuali in esecuzione su tutti i dispositivi connessi. È possibile passare in qualsiasi momento alla prospettiva DDMS utilizzando la voce di menu Finestra – Apri prospettiva – Altro – DDMS (Finestra – Apri prospettiva – Altro – DDMS). Sulla fig. La Figura 2.13 mostra l'aspetto tipico della prospettiva DDMS.
Riso. 2.13. DDMS in azione
Come con altre prospettive, abbiamo alcuni punti di vista speciali che svolgono un lavoro utile per noi. In questo caso, vogliamo raccogliere informazioni su tutti i processi, le loro macchine virtuali, i thread, lo stato corrente della memoria, i dati da LogCat su un dispositivo specifico, ecc. Consideriamo queste viste.
Dispositivi: mostra tutti i dispositivi e gli emulatori collegati, nonché i processi in esecuzione su di essi. Utilizzando i pulsanti sulla barra degli strumenti, puoi eseguire varie azioni: eseguire il debug del processo selezionato, registrare lo stato della memoria e i dati dai thread e acquisire schermate.
LogCat - Come descritto nella sezione precedente, con una differenza: visualizza le informazioni dal dispositivo selezionato nella vista Dispositivi.
Controllo emulatore: consente di modificare il comportamento di un'istanza dell'emulatore in esecuzione. Ad esempio, puoi far generare coordinate GPS di esempio a scopo di test.
Thread - Visualizza i thread utilizzati dal processo selezionato nella vista Dispositivi. Le informazioni verranno mostrate solo se hai abilitato il monitoraggio del flusso (questo può essere fatto facendo clic sul quinto pulsante da sinistra nella vista Dispositivi).
Heap (non mostrato nella Figura 2.13) - Fornisce informazioni sullo stato della memoria del dispositivo. Come per i dati dei thread, è necessario abilitare esplicitamente il rilevamento della memoria nella vista Dispositivi facendo clic sul secondo pulsante da sinistra.
Allocation Tracker - Mostra le classi utilizzate più di recente. Questo è molto utile per affrontare le perdite di memoria.
Esplora file (Explorer): consente di modificare i file su un dispositivo Android connesso o su un'istanza dell'emulatore. Puoi trascinare e rilasciare i file in questa vista proprio come faresti con il sistema operativo.
DDMS è in realtà un'applicazione autonoma integrata in Eclipse utilizzando il plug-in ADT. Puoi anche eseguirlo separatamente dalla directory $ANDROID H0M E/tools (%ANDROID HOME%/tools su Windows). Non si collega direttamente ai dispositivi, utilizzando Android Debug Bridge (ADB), un'altra utility inclusa con l'SDK. Consideriamolo per integrare la nostra conoscenza dell'ambiente di sviluppo Android.
Usando ADB
ADB ti consente di gestire i dispositivi connessi e le istanze dell'emulatore. Si compone di tre diversi componenti.
Un'applicazione client in esecuzione sulla macchina dello sviluppatore che utilizza il comando adb (questo comando funzionerà se imposti correttamente le variabili di ambiente). Quando parliamo di ADB, intendiamo solo questa utilità della riga di comando.
Un server in esecuzione anche sulla macchina di sviluppo. Si installa come servizio in background ed è responsabile della connessione tra il programma ADB e qualsiasi dispositivo connesso o istanza dell'emulatore.
Il demone ADB, che è anche un processo in background e funziona su ogni telefono o emulatore. Il server ADB utilizza questo demone per connettersi.
Di solito utilizziamo ADB tramite DDMS, ignorando l'esistenza di un'utilità della riga di comando separata. Ma a volte è utile eseguirlo separatamente, quindi diamo una rapida occhiata ad alcune delle sue funzionalità.
NOTA
Per un riferimento completo dei comandi disponibili, vedere la documentazione ADB sul sito degli sviluppatori Android (http://developer.android.com).
Un compito molto utile svolto con ADB è quello di ottenere un elenco di tutti i dispositivi e gli emulatori collegati al server ADB (e quindi al computer). Per fare ciò, esegui il seguente comando della console (nota: il simbolo non fa parte del comando):
Di conseguenza, sullo schermo verrà visualizzato un elenco di tutti i dispositivi collegati e gli emulatori con i numeri di serie corrispondenti:
Il numero di serie del dispositivo o dell'emulatore viene utilizzato per eseguire i comandi successivi. Ad esempio, il comando seguente installerà il file APK myapp. e pk dalla macchina dello sviluppatore al dispositivo con numero di serie NT019R803783:
L'argomento -s può essere utilizzato con qualsiasi comando ADB che esegue alcune azioni su un dispositivo specifico.
Ci sono anche comandi per copiare i file tra il computer e il dispositivo (emulatore). Il risultato del comando seguente è copiare il file locale myfi1e. txt sulla scheda di memoria del dispositivo con il numero di serie HT019P803783:
Per eseguire il backup di fi1e. txt da una scheda di memoria, utilizzare il seguente set di caratteri:
Se al server ADB è attualmente connesso un solo dispositivo o emulatore, puoi omettere il numero di serie: adb lo rileverà automaticamente.
Naturalmente, le possibilità di ADB non si limitano alle funzioni che abbiamo descritto. Molti di questi sono implementati tramite DDMS e nella maggior parte dei casi non utilizzeremo la riga di comando. Tuttavia, per piccoli compiti è la soluzione ideale.
Riassumendo
L'ambiente di sviluppo Android a volte può intimidire. Fortunatamente, per iniziare è necessaria solo una parte della funzionalità.
La cosa più importante che dovresti capire dopo aver studiato è come funziona tutto insieme. Il JDK e l'SDK Android fungono da base per tutto lo sviluppo Android. Offrono strumenti per la compilazione, la distribuzione e l'esecuzione di applicazioni su istanze e dispositivi di emulatore. Per accelerare il processo di sviluppo, utilizziamo Eclipse in combinazione con il plug-in ADT, che ci evita l'inconveniente di lavorare con JDK e SDK sulla riga di comando. Eclipse stessa si basa su diversi concetti fondamentali: spazi di lavoro che gestiscono i progetti; viste che offrono funzionalità speciali (ad esempio, la modifica del codice del programma o l'output di LogCat); prospettive che combinano le viste per eseguire determinate attività (ad esempio, il debug); configurazioni di esecuzione e di debug, che consentono di definire le opzioni di avvio o di debug per l'applicazione.
Un prerequisito per padroneggiare tutta questa ricchezza è la pratica, non importa quanto possa sembrare noioso. Nel corso dello studio, implementeremo progetti che ti introdurranno all'ambiente di sviluppo Android. Tuttavia, non fermarti qui: sta a te decidere se fare i passi successivi.
Ora che hai digerito tutte queste informazioni, puoi passare a ciò per cui hai iniziato tutto: lo sviluppo del gioco.
