Share
Mobiletuts + coprirà tutte le principali piattaforme mobili: iPhone, Windows, Android e Blackberry. Oggi daremo un'occhiata allo sviluppo di Android: spiegando perché le persone hanno scelto di lavorare con Android e fornire una panoramica dell'IDE di Eclipse e delle sue prospettive Java, DDMS e di debug. Infine, imparerai come iniziare a creare la tua prima app per Android!
Android è un sistema operativo mobile open source che combina e costruisce su parti di molti diversi progetti open source. Cosa significa questo per te come sviluppatore? Hai accesso al codice sorgente della piattaforma che è in esecuzione sul telefono. Questo può aiutarti a capire meglio come funzionano i controlli dell'interfaccia e le varie parti. Se ti capita di trovare un bug, puoi anche inviare una patch per il problema, anche se questa è una pratica più avanzata. Google ha anche riunito un ampio gruppo di aziende (chiamate Open Handset Alliance) che contribuiscono e utilizzano il sistema operativo Android nei loro dispositivi hardware. Ciò significa che esiste un supporto a livello di settore per il sistema operativo di Google, promettendo un'ampia adozione da parte di noti fornitori.
Ci sono molti vantaggi nello sviluppo per la piattaforma Android:
I prerequisiti prima di continuare con questo articolo includono:
Eclipse è un ambiente di sviluppo integrato (IDE) complesso, multi-lingua ed estendibile. La curva di apprendimento può essere ripida, ma la potenza dell'ambiente può aumentare notevolmente la tua efficienza.
Dopo aver aperto Eclipse per la prima volta, seleziona uno spazio di lavoro in cui salvare il tuo progetto. Vedrai una schermata introduttiva con più icone. Seleziona l'opzione "vai al banco di lavoro" e ti verrà presentata la schermata di progetto predefinita.
Supponendo di aver già installato il plug-in Eclipse ADT, sarà necessario configurare Eclipse per lo sviluppo Android impostando manualmente il percorso file per l'SDK di Android. Per fare ciò, selezionare Eclipse> Preferenze dalla barra degli strumenti principale, quindi selezionare Android dalla finestra di dialogo che appare. Aggiorna l'opzione "Posizione SDK" per puntare alla directory in cui hai installato l'SDK. Ora dovresti avere l'IDE configurato per lo sviluppo Android.
È importante notare che Eclipse utilizza qualcosa chiamato "prospettive" per raggruppare attività di uso comune. Cambiando le prospettive, le parti del menu e le barre degli strumenti verranno disattivate e mostreranno e nasconderanno le viste ad esse relative. Le prospettive possono essere aperte facendo clic sul pulsante Apri prospettiva o scegliendo Finestra> Apri prospettiva. Alcune prospettive che userete frequentemente includono Java, Debug e DDMS.
La prospettiva Java è la prospettiva predefinita in Eclipse, ed è qui che probabilmente trascorrerai la maggior parte del tuo tempo.
Tra le visualizzazioni più importanti in questa prospettiva è la vista Esplora pacchetti, per impostazione predefinita, situata nella colonna a sinistra del workbench. Questa vista è una panoramica dell'intero progetto. Mostra anche gli stati dei singoli file in relazione a problemi di compilazione, controllo della versione, ecc.
Un'altra vista importante nella prospettiva Java è la vista Problemi, per impostazione predefinita situata nel pannello centrale in basso del workbench. Qui troverai gli avvisi e gli errori di compilazione elencati. È possibile fare doppio clic su un elemento da portare direttamente all'errore nel file Java o XML.
DDMS è l'abbreviazione di Dalvik Debug Monitor Server, che comunica con i servizi di basso livello di un dispositivo o emulatore. Passa ora alla prospettiva DDMS selezionando Finestra> Apri prospettiva> DDMS.
La vista Dispositivi, situata nella colonna di sinistra del workbench, è dove potrai vedere tutti i dispositivi Android disponibili sul tuo computer. Ciò include sia i telefoni collegati al computer che gli emulatori in esecuzione. Sotto ogni dispositivo, vedrai tutti i processi in esecuzione. Sulla vista sono presenti i pulsanti della barra degli strumenti per l'avvio del debugger in un processo, l'acquisizione di informazioni su heap e thread, l'interruzione dei processi e la cattura di schermate.
La vista Controllo emulatore, anche nella colonna di sinistra, ti consente di effettuare le seguenti operazioni:
Utilizzando la vista Esplora file, accessibile come una scheda nella parte in alto a destra della colonna centrale, è possibile sfogliare il file system di un dispositivo. Per un emulatore o un telefono rooted avrai accesso alle directory / dati e / al sistema privati. Per i telefoni non rooted avrai accesso solo a / sdcard.
La prospettiva del debug fornirà informazioni approfondite sulle tue applicazioni. Passa ora alla prospettiva di debug selezionando Finestra> Apri prospettiva> Debug.
La vista Debug ti mostrerà le app in esecuzione che vengono analizzate e, quando viene arrestato su un punto di interruzione o un'eccezione, anche lo stack di chiamate dell'applicazione. La vista Variabili mostra il contenuto di qualsiasi variabile locale nel punto di interruzione corrente.
La vista LogCat nell'angolo in basso a destra mostra tutti gli output di logging usando la classe android.util.Log. È possibile filtrare in base ai tag o a diversi livelli di registro come debug, informazioni, errori, ecc.
Per iniziare a creare un'applicazione Android, tornare alla prospettiva Java e selezionare File> Menu> Progetto Android. In questo modo verrà avviata la procedura guidata per la creazione dell'applicazione e verrà richiesto di inserire le metainformazioni sul progetto in tre categorie: Contenuti, Crea target e Proprietà.
Denominare l'applicazione "DemoApp" e lasciare la sezione Contenuto con tutti i valori predefiniti.
La sezione Build Target definisce la versione dell'SDK con cui verrà compilata la nostra app demo. Per questo tutorial, scegli API 4 (Android 1.6) perché verrà eseguito su una vasta gamma di hardware e l'API ci consentirà di gestire diverse risoluzioni dello schermo.
La prossima è la sezione Proprietà, che fornisce alla procedura guidata maggiori informazioni su quali classi generare e su quali dovrebbero essere denominate. L'impostazione Nome applicazione verrà visualizzata sotto l'icona dell'applicazione, così come la barra del titolo dell'applicazione quando viene avviata. Il nome del pacchetto fornisce lo spazio dei nomi Java di base per le classi generate. Per creare un'attività predefinita, assicurati che l'opzione Crea attività sia selezionata e fornisca un nome dell'attività. L'ultima opzione è la versione Min SDK. Questo valore determina quale versione di Android deve essere installata su un telefono affinché questa applicazione sia installabile. Questo è generalmente impostato sullo stesso livello API che hai scelto in Build Target.
Una volta inserite tutte queste informazioni e fatto clic su Fine, si avrà un'applicazione di base "Hello World" che è quasi pronta per essere eseguita su un telefono o un emulatore. Prima di configurare un emulatore ed eseguire l'applicazione, dedicare alcuni minuti all'esame del contenuto del modello standard generato:
Il file AndroidManifest.xml fornisce metadati relativi alla tua applicazione che il sistema operativo Android dovrà eseguire correttamente. Il nome dell'applicazione, utilizzato sia per l'icona dell'app che per la barra del titolo dell'attività e l'icona dell'app, sono definiti in Attributi dell'applicazione. Noterai che il campo Nome in realtà non contiene il testo del nome, ma "@ string / nome_app". Questo è un riferimento alle stringhe e può essere utilizzato ogni volta che è prevista una stringa. Il testo della stringa effettiva viene quindi definito in uno dei file XML trovati nella cartella res / values. La procedura guidata per la creazione di app ha generato un file chiamato strings.xml.
La sezione Nodi applicativi è dove vengono definite tutte le attività per l'applicazione. La singola attività della nostra app si chiama MainActivity ed è elencata qui.
La cartella res è dove sono archiviate la maggior parte delle risorse dell'applicazione. Le principali categorie di contenuti includono drawable, layout e valori.
I drawable sono generalmente immagini bitmap sotto forma di PNG. I drawable possono anche essere immagini a nove patch, che sono .PNG con dati speciali nell'immagine che aiutano Android a fare un lavoro migliore durante lo stretching dell'immagine. È possibile creare immagini a nove patch con gli strumenti a nove patch nell'SDK o con uno strumento di creazione di immagini come Photoshop.
I layout sono dove definisci i tuoi schermi. Per visualizzare l'XML per il layout sullo schermo, fare clic sulla scheda main.xml.
I valori sono dove si definiscono (in XML) i colori, le dimensioni, le stringhe e gli stili utilizzati globalmente. Il file strings.xml ti consente di aggiungere e modificare valori per il tuo progetto.
È qui che viene generato il codice per tutte le risorse definite nella cartella di ricerca. In questo modo è possibile accedere a layout e controlli definiti all'interno del codice.
La cartella src contiene tutto il tuo codice sorgente personalizzato, raggruppato in pacchetti. I pacchetti sono semplicemente lì per aiutare a categorizzare il codice sorgente in gruppi logici (e gestibili).
La cartella delle risorse è un luogo in cui archiviare i vari file necessari per accedere al codice come dati non elaborati. Tutti i file nella cartella res hanno metodi per caricare i tipi specifici, mentre l'unico modo per caricare qualcosa dalle risorse è di aprirlo a livello di programmazione come un file.
I dispositivi virtuali consentono di eseguire e testare il codice senza possedere un vero telefono Android. Dal momento che ci sono diverse versioni del sistema operativo che puoi scegliere come destinazione, alla fine dovrai creare più versioni di dispositivi virtuali, ma per ora ne creeremo una utilizzando l'API di livello 4 (1.6). È possibile farlo tramite AVD Manager. Dalla barra degli strumenti principale, selezionare Finestra> Android SDK e AVD Manager.
Una volta aperto il gestore e visualizzato il tuo elenco di dispositivi virtuali, fai clic sul pulsante "Nuovo" per creare il tuo dispositivo virtuale.
Generalmente i miei dispositivi virtuali chiamano i numeri di versione del sistema operativo insieme alla risoluzione predefinita che scelgo, quindi, in questo caso, 1.6-hvga. È bene anche creare una scheda SD per l'emulatore che di solito metto a 16 MB, a meno che non sappia che avrò bisogno di più spazio. Fai clic sul pulsante Crea AVD e vedrai il tuo dispositivo elencato.
Vai avanti e avvia il dispositivo virtuale selezionandolo e facendo clic sul pulsante "Start".
Eclipse, insieme agli strumenti per sviluppatori Android, offre un ottimo ambiente per il debug delle applicazioni. Per il debug, utilizzerai sia il debugging che il DDMS. La prospettiva di debug verrà utilizzata per esaminare il codice, visualizzare i valori delle variabili e impostare i breakpoint. La prospettiva DDMS verrà utilizzata per controllare l'emulatore, visualizzare i thread e visualizzare l'allocazione della memoria.
Poiché è la prima volta che eseguiamo l'applicazione, dobbiamo creare qualcosa chiamata configurazione di esecuzione. Le configurazioni di esecuzione sono le impostazioni che Eclipse utilizzerà per eseguire (o eseguire il debug) l'applicazione. Ogni applicazione può avere più configurazioni. Uno potrebbe essere impostato per essere sempre distribuito ed eseguito su un telefono collegato, e un altro potrebbe essere configurato per essere eseguito solo in un'istanza specifica dell'emulatore. A questo punto, scollega il telefono se ti è capitato di collegarlo alla tua macchina in modo da poter vedere prima l'app eseguita sull'emulatore.
Per creare la configurazione dell'esecuzione, selezionare DemoApp in Package Explorer, quindi selezionare Esegui> Esegui dal menu principale. Nella finestra di dialogo successiva, scegli Applicazione Android e fai clic su OK. L'emulatore creato in precedenza dovrebbe essere avviato. Quando l'emulatore si avvia per la prima volta, potrebbe apparire con la schermata di blocco; fai semplicemente clic sul menu per accedere alla tua nuova app. Ora dovresti vedere il testo "Hello World" sullo schermo!
Il nostro prossimo passo sarà quello di impostare un punto di interruzione. Aprire il file MainActivity.java facendo doppio clic su Esplora pacchetti. Si trova sotto / src> com.demo.demoapp. Successivamente, sulla riga che contiene:
"Super.onCreate (savedInstanceState)"
fai doppio clic nella colonna grigia a sinistra della linea (dove vedi il cerchio blu nello screenshot qui sotto). Se hai avuto successo, ora dovrebbe esserci un cerchio blu che indica il punto di interruzione.
Passare ora alla prospettiva di debug selezionando Finestra> Apri prospettiva> Debug . Per eseguire il debug dell'applicazione, selezionare Esegui> Debug.
Nella vista Debug, dovresti vedere un elenco di elementi sotto DalvikVM / Thread. Questo è lo stack delle chiamate poiché ora ci fermiamo nel punto di interruzione impostato in precedenza. La vista Variabili mostrerà tutte le variabili locali nel punto di interruzione corrente. È possibile espandere l'elemento "questo" per vedere tutti i valori della nostra istanza MainActivity.
Infine, LogCat mostrerà tutte le informazioni di registrazione provenienti dall'emulatore.
Per continuare a eseguire l'app, puoi utilizzare la barra degli strumenti nella vista Debug (come mostrato nella schermata sopra) o scegliere le stesse azioni dal menu di esecuzione. Scegliere Esegui> Ripristina per consentire all'app di continuare a essere eseguita.
Questo tutorial ti ha portato attraverso le varie parti di Eclipse e ADT con cui devi familiarizzare per iniziare lo sviluppo di Android. Sebbene non abbiamo trattato i dettagli del codice sorgente dell'applicazione, è importante iniziare con una forte comprensione degli strumenti che userete ogni giorno durante lo sviluppo. Nei prossimi articoli, continueremo a scavare più a fondo nella scrittura di applicazioni progressivamente complesse e nella creazione di un'interfaccia utente accattivante.
Accentsconagua