Allontaniamoci un po' dall'argomento dei markup. Tutto è cambiato molto sul sito dell'Alma Mater. Android Studio è ora l'ambiente per lo sviluppo di app Android. Ma poiché molti esempi e tutorial sono incentrati su Eclipse, vale comunque la pena averlo nel tuo arsenale.
Inoltre, è stato rilasciato Java 8. E in connessione con tutto questo, installeremo ancora una volta JDK, Eclipse + ADT, quindi Android Studio e JetBrains IntelliJ IDEA 14.0.2. Bene, a colpo sicuro Genymotion.
E allora, andiamo!
1) Installa JDK
E scegli Download JDK
Siamo d'accordo con la licenza
E scegli la versione da scaricare in base al bit di Windows (io ho Win 8.1 x64).
Scaricato, esegui JDK per l'installazione
durante il processo di installazione, verrà installato anche il JRE
Facciamo tutti clic su Chiudi. Questo completa l'installazione di JDK.
Verifica dell'installazione di JDK con il comando java-versione.
Se vediamo un output simile del comando (potrebbe differire per te se hai scaricato una versione o build diversa di java), allora va tutto bene. Vai avanti.
2) Installazione di Eclipse
E scarica gli strumenti SDK autonomi
Scarichiamo esattamente l'archivio zip con l'SDK e poi lo decomprimiamo in C: \ android-sdk-windows (puoi scegliere un'altra directory, a seconda di quale sia conveniente). Vediamo quanto segue
Questo completa l'installazione dell'SDK.
4) Installazione del plug-in ADT per Eclipse
Iniziamo Eclipse. Scegli Installa nuovo software
E nella finestra che si apre, inserisci l'indirizzo https://dl-ssl.google.com/android/eclipse/
Premere Invio. Stiamo aspettando che Eclipse trovi i pacchetti da installare. Contrassegniamo tutto come nello screenshot e facciamo clic su Avanti
Attendi un po' e fai di nuovo clic su Avanti
Accettiamo le licenze
Potrebbe esserci un avviso come questo
Basta fare clic su OK
Una volta installato, Eclipse ti chiederà di riavviare per rendere effettive le modifiche.
Siamo d'accordo e dopo il riavvio vediamo un'immagine del genere
ADT ha giurato di non aver visto l'SDK di Android e questo è normale, poiché non sa dove sia. Ma glielo diremo.
Fare clic su Chiudi ed Eclipse ci chiederà di inserire il percorso dell'SDK Android
Scegli il percorso in cui abbiamo decompresso l'SDK Android e fai clic su Avanti
E fare clic su Fine
Posso giurare così
Fare clic su Apri Gestione SDK
Per ora, è importante scegliere ciò che è contrassegnato in giallo. Altri pacchetti possono essere installati in qualsiasi momento.
Fare clic su Installa...
Siamo d'accordo con le licenze e facciamo nuovamente clic su Installa e attendiamo che tutto venga scaricato e installato
Durante l'installazione, potrebbe essere visualizzato un registro
Non dovresti avere paura
Il download e l'installazione degli SDK Android possono richiedere molto tempo.
Alla fine dovresti vedere una finestra del genere
che può essere chiuso. Anche in questa finestra di Eclipse, puoi fare clic su Chiudi
E riavvia Eclipse
Ora vediamo che Eclipse si è avviato senza problemi ed errori, ed è anche chiaro che vede l'SDK di Android.
Ora resta da rispolverare un po' il tutto ed eseguire la prima applicazione di prova per verificare il funzionamento di tutta questa economia.
5) Installa pacchetti Android SDK aggiuntivi
I pacchetti vengono inseriti in base alla necessità di sapere. Quelli. se vuoi sviluppare e testare i tuoi programmi in diverse versioni di Android, devi installare i pacchetti necessari. Possono essere rimossi o aggiunti in qualsiasi momento.
Per la prima volta, puoi installare tali pacchetti (beh, o qualunque cosa tu ritenga opportuno)
Dopo aver scaricato questi pacchetti, il papà dell'SDK di Android ha iniziato a pesare quasi 7,5 GB
Quindi calcola lo spazio sui tuoi dischi.
6) Configurazione della posizione di archiviazione AVD (dispositivi virtuali Android).
Per impostazione predefinita, l'SDK Android crea e archivia i file AVD nella directory
C:\Utenti\UTENTE\.android\avd
Questo non è molto conveniente per me, quindi trasferirò questa cartella nella directory C:\AVD
Per questo
1. Crea una cartella C:\AVD
2. Creare una variabile di ambiente Windows chiamata ANDROID_SDK_HOME e un parametro che punta alla nostra directory
3. Copiare la sottodirectory .android nella directory H:\AVD
4. Esegui AVD Manager e verifica che la sua directory si trovi nella nuova posizione in cui abbiamo specificato
Non abbiamo ancora creato AVD, ma lo sistemeremo.
Nel frattempo, è necessario installare e configurare Intel® HAXM
7) Installazione e configurazione di Intel Hardware Accelerated Execution Manager (Intel® HAXM)
Requisiti di sistema e istruzioni di installazione qui:
Puoi installarlo sia manualmente che tramite l'SDK di Android. Ma ho scelto di installare manualmente, poiché il sito Intel di solito contiene una versione più recente di HAXM.
E quindi scarichiamo HAXM qui (al momento la versione 1.1.1 e il file pesa solo 1.7Mb):
Decomprimi ed esegui il file di installazione
Per verificare che tutto sia installato correttamente e funzioni, è necessario eseguire dalla riga di comando:
sc interrogare intelhaxm
Dopo aver eseguito questo comando, vedrai lo stato corrente del servizio
Potrebbe anche essere necessario un modo per interrompere il servizio:
sc stop intelhaxm
Avvia il servizio:
sc avviare intelhaxm
Con questo, ci siamo solo preparati per il lancio di AVD. Ora devi creare un dispositivo AVD
8) Creare un AVD
Avvia Gestione AVD
Creiamo un AVD. In CPU / ABI seleziona Intel Atom
Dopo aver fatto clic su OK, verranno visualizzate le informazioni sull'AVD creato
E di conseguenza vediamo il nostro AVD
E lo lanciamo premendo Start...
Di conseguenza, vediamo l'emulatore in funzione
L'emulatore Android 2.2.3 si è avviato abbastanza velocemente e funziona anche quasi senza freni. Creiamo un AVD Android 4.x e vediamo come si comporta
Questo è in esecuzione da molto più tempo
Si può vedere che HAXM funziona
Ma in un modo o nell'altro, la velocità di AVD su Android 4.1.2 è abbastanza decente. Molto meglio di un anno fa.
E un altro trucco. Se imposti troppa RAM per AVD
Come possiamo vedere, appare l'icona di un triangolo giallo con un punto esclamativo. E quando avvii l'emulatore giura su questo e potrebbe non avviarsi
È trattato in modo molto semplice. Necessità di aprire il file \.android\avd\
È vero, il tempo di avvio è ancora molto più lungo rispetto a AVD 2.x
Ora resta da verificare il lancio del vero programma sull'AVD.
9) Eseguire il programma di test su AVD
Avvio di Eclipse e creazione di un'applicazione di prova
Il maestro ha generato un progetto per noi
Bene, eseguiamolo su AVD 2.x
Tutto funziona. Ma l'AVD è una cosa molto capricciosa e imprevedibile. Pertanto, faremmo meglio a mettere Genymotion.
10) Installa Genymotion
L'installazione di Genymotion consiste in due passaggi: l'installazione di VirtualBox e l'installazione di Genymotion stesso. Genymotion utilizza VirtualBox per installare macchine virtuali Android.
E così scarichiamo VirtualBox dal sito web del produttore https://www.virtualbox.org/wiki/Downloads
e installarlo
Verrà fuori un avviso e siamo d'accordo con esso
Configurazione di VirtualBox
Specificare dove verranno archiviate le macchine virtuali
E questo è tutto. Per ogni evenienza, dopo aver installato VirtualBox, è meglio riavviare il computer.
Ora installa Genymotion
E registrati (se non sei già registrato) per scaricare la versione gratuita
L'attuale versione di Genymotion è la 2.3.1
E così abbiamo impostato
Configurazione di Genymotion
Ora dobbiamo aggiungere dispositivi virtuali
Per fare ciò, inserisci ancora una volta il nostro login e password, che abbiamo creato al momento della registrazione al sito.
Successivamente, otterremo un elenco di dispositivi che possono essere scaricati e installati.
Possono essere filtrati per versione e dispositivo Android
Qui vediamo che ci vengono mostrati solo dispositivi con Android 2.3.7
Ma prima di scaricare i dispositivi, devi modificare leggermente Genymotion. Per fare ciò, fai clic su Annulla e vai alle impostazioni di Genymotion
E specifica il percorso della directory precedentemente creata in cui verranno archiviate le macchine virtuali
Oltre al percorso della directory con l'SDK di Android
Ora fai clic su OK e procedi con l'aggiunta di dispositivi
Ho scelto Google Nexus One 2.3.7
E anche Google Nexus S 4.1.1
Ecco come sembrano installati
Per avviare il dispositivo, premere start. Ho lanciato Google Nexus One 2.3.7 e ho controllato l'avvio dell'applicazione di test su di esso.
In linea di principio, da Eclipse puoi eseguire facilmente applicazioni in Genymotion senza plug-in, ma per comodità integreremo Genymotion con Eclipse.
Per fare ciò, installa il plug-in Genymotion in Eclipse
Premi Invio, attendi che venga visualizzato il plugin, contrassegnalo e fai clic su Avanti
Dopo il riavvio, vediamo l'icona di avvio di Genymotion nella barra degli strumenti di Eclipse
Facciamo clic su di esso e vediamo tale letame
È necessario specificare il percorso della directory Genymotion. Fare clic su OK e specificare il percorso della directory
Ora, quando facciamo clic sull'icona Genymotion sul pannello, lo vedremo
Bene, questo è quasi tutto. Ora ci sono piccole modifiche estetiche all'aspetto di Eclipse, cosa che di solito faccio sempre. Bene, in linea di principio puoi eliminare tutte le immagini dei dispositivi virtuali AVD che abbiamo scaricato in SDK Manager, poiché, in generale, non ce n'è bisogno, occupano spazio e non sono piccoli.
Vai su Aiuto -> Eclipse Marketplace
E nella ricerca guidiamo in Jeeeyul e quindi installiamo questo plugin.
Bene, con il suo aiuto, coloriamo tutto come vogliamo.
Il mio Eclipse dopo le impostazioni è simile a questo
Quello che mi piace di questo plugin è che puoi creare temi e quindi esportarli e importarli.
Ora rimuoviamo i pacchetti del dispositivo Intel AVD.
La cartella SDK prima dell'eliminazione pesa 7,5 GB
Dopo la rimozione pesa 3 GB
La differenza totale è di 4,5 GB…. non poco
Sembra essere tutto. Ora aggiungiamo Android Studio a questo kit, ma questo è nel prossimo argomento.
Android fornisce un plug-in speciale per l'IDE Eclipse chiamato Android Development Tools (ADT). Fornisce un potente IDE in cui puoi creare app Android. ADT estende la potenza di Eclipse in modo che tu possa creare rapidamente e facilmente un nuovo progetto Android, progettare l'interfaccia utente di un'applicazione, eseguire il debug di un'applicazione ed esportare file APK per distribuire la tua applicazione.
Commento: Se preferisci lavorare in un IDE diverso, non è necessario installare né Eclispe né ADT. Invece, puoi utilizzare direttamente le capacità dell'SDK per creare ed eseguire il debug della tua applicazione.
Scarica il plug-in ADT
- Avvia Eclipse, seleziona Aiuto > Installa nuovo software.
- Clic Aggiungere nell'angolo in alto a destra.
- Nella finestra di dialogo Aggiungi repository che appare, inserisci "ADT Plugin" nel campo Nome e il seguente URL nel campo Posizione:
https://dl-ssl.google.com/android/eclipse/
- Clic OK.
- Nella finestra di dialogo Software disponibile, seleziona la casella accanto a Strumenti per sviluppatori e fai clic Prossimo.
- Nella finestra successiva, vedrai un elenco di strumenti da scaricare. Clic Prossimo.
- Leggere e accettare il contratto di licenza, quindi fare clic Fine.
- Al termine dell'installazione, riavvia Eclipse.
Configurazione del plug-in ADT
Dopo aver riavviato Eclipse, devi specificare la directory con il tuo SDK Android:
- Selezionare Usa gli SDK esistenti nella finestra che appare.
- Trova e seleziona la directory contenente l'SDK Android che hai scaricato e decompresso di recente.
- Clic Prossimo.
Risoluzione dei problemi di installazione
Se hai difficoltà a scaricare il plug-in ADT dopo i passaggi precedenti, ecco alcune soluzioni:
- Se Eclipse non riesce a trovare il sito di aggiornamento remoto contenente il plug-in ADT, prova a cambiare il collegamento del sito in
http://dl-ssl.google.com/android/eclipse/
- Se hai un firewall (o firewall aziendale) abilitato, assicurati di aver inserito le impostazioni proxy corrette in Eclipse. In Eclipse, puoi configurare il proxy dal menu principale da Finestra(su Mac OS X, Eclisse)> Preferenze > Generale > Le connessioni di rete.
Se non riesci ancora a scaricare il plug-in ADT utilizzando Eclipse dal sito di aggiornamento remoto, puoi scaricare il file zip ADT sul tuo computer e installarlo manualmente:
Per utenti Linux
In caso di problemi durante l'installazione del plug-in ADT per la visualizzazione Eclipse:
Si è verificato un errore durante il provisioning. Impossibile connettersi al keystore. JKS
Ciò significa che non hai una VM Java adatta sul tuo computer. L'installazione di Sun Java 6 risolverà questo problema e quindi potrai reinstallare il plug-in ADT.
In questo tutorial imparerai come avviare lo sviluppo di Android, ovvero: applicazioni mobili su piattaforma Android Eclipse + SDK. Oggi esistono molti approcci allo sviluppo e alla creazione di app mobili per Android. Sofisticati dispositivi hardware, tablet PC e varie piattaforme software (Symbian OS, iOS, WebOS, Windows Phone 7…) aprono uno spazio infinito per gli sviluppatori.
Quindi, l'elenco delle applicazioni per iniziare a sviluppare applicazioni mobili per Android è enorme. Quale piattaforma scegliere? Quale linguaggio di programmazione imparare? Quale insieme di applicazioni scegliere per la pianificazione del progetto? In questo tutorial imparerai come iniziare a sviluppare app mobili per la piattaforma Android, il sistema operativo mobile open source di Google.
Perché la piattaforma Android?
Android è una piattaforma aperta basata sul kernel Linux. È installato su migliaia di dispositivi di una vasta gamma di produttori. Android fornisce app per ogni tipo di hardware immaginabile nei dispositivi mobili di oggi: bussole digitali, videocamere, GPS, sensori e altro ancora.
Gli strumenti di sviluppo Android gratuiti ti consentono di iniziare rapidamente a creare app gratuite o quasi gratuite. Quando sei pronto per mostrare al mondo il tuo programma, puoi pubblicarlo tramite l'Android Market. La pubblicazione su Android Market richiede una quota di registrazione una tantum ($ 25 al momento della stesura) e, a differenza dell'App Store di Apple (che è molto severo in termini di idoneità), rende la tua app disponibile per il download e l'acquisto dopo una rapida revisione, a meno che il l'app infrange le regole e la legge.
Ecco alcune altre funzionalità di Android SDK che ti offrono vantaggi come sviluppatore:
- L'SDK Android è disponibile per Windows, Mac e Linux, quindi non devi pagare per il nuovo hardware per scrivere app.
- SDK integrato in Java. Se hai familiarità con il linguaggio di programmazione Java, sei già a metà strada.
- Data la distribuzione dell'applicazione tramite l'Android Market, sarà immediatamente disponibile per centinaia di migliaia di utenti. Non sei limitato al mercato ufficiale, in quanto ci sono alternative. Ad esempio, puoi pubblicare l'app sui tuoi blog. Si dice che Amazon stia preparando il proprio app store Android.
- Oltre alla documentazione tecnica dell'SDK, vengono create nuove risorse per gli sviluppatori Android. La piattaforma sta guadagnando sempre più popolarità tra utenti e sviluppatori.
Basta parlare: iniziamo lo sviluppo di app Android!
Installazione di Eclipse e SDK Android
Orientamento per la piattaforma Android durante lo sviluppo
Prima di iniziare a scrivere applicazioni Android, devi scaricare l'SDK per la piattaforma Android. Ogni piattaforma ha la propria versione dell'SDK Android installata sui dispositivi degli utenti. Per Android 1.5 e versioni successive, ci sono due piattaforme: Android Open Source Project e Google.
L'Android Open Source Project è una piattaforma open source ma non include estensioni di Google come Google Maps. Se non desideri utilizzare l'API di Google, la funzionalità di Google Maps non sarà disponibile per la tua applicazione. A meno che tu non abbia un motivo specifico per farlo, ti consiglio di scegliere come target una delle piattaforme Google, in quanto ciò ti consentirà di utilizzare le estensioni di Google.
- Seleziona Finestra->Android SDK e AVD Manager.
- Fai clic su Pacchetti disponibili nella colonna di sinistra e controlla il repository per mostrare un elenco di piattaforme Android disponibili.
- Puoi selezionare le piattaforme da scaricare dall'elenco o lasciare tutte selezionate per scaricare tutte le piattaforme disponibili. Al termine, fare clic su Installa selezionati e seguire le istruzioni di installazione.
Una volta che tutto è stato caricato correttamente, sei pronto per iniziare lo sviluppo di Android.
Creazione di un nuovo progetto Android
Eclipse New Project Wizard ti aiuterà a creare un'applicazione Android generando file e codice pronti per essere eseguiti sul lato destro del blocco. Questo è un modo rapido per assicurarsi che funzioni e un buon punto di partenza quando si inizia a sviluppare applicazioni:
Dopo aver fatto clic su Fine, Eclipse creerà un nuovo progetto Android pronto per essere eseguito e sviluppato per Android. Ricordi quando hai detto a Eclipse di generare un'attività chiamata BrewClockActivity? Questo è il codice che Android utilizza effettivamente per eseguire l'app. Il codice generato verrà visualizzato come un semplice messaggio "Hello World".
Pacchi
Il nome del pacchetto è un identificatore per la tua applicazione. Quando è il momento di pubblicare il risultato nell'Android Market, questo ID verrà utilizzato per tenere traccia degli aggiornamenti per l'app, quindi è importante assicurarsi che questo ID sia univoco. Sebbene qui utilizziamo il nome com.example.brewclock, per un'applicazione reale è meglio scegliere qualcosa come com.nomeazienda.tuaapplicazione.
Versioni dell'SDK
La versione Min SDK (il nome dice tutto) è la prima versione di Android su cui verrà eseguita l'app. Con ogni nuova versione di Android, l'SDK aggiunge e modifica vari metodi. Quando selezioni una versione dell'SDK, Android (e Android Market) sa che la tua app verrà eseguita solo su dispositivi che eseguono la versione della piattaforma Android della versione specificata e successive.
Avvio della tua applicazione
Ora proviamo a eseguire la nostra applicazione in Eclipse. Poiché questa è la prima esecuzione, Eclipse ti chiederà con quale tipo di progetto stai lavorando:
- Seleziona Esegui->Esegui o premi Ctrl+F11.
- Seleziona Applicazione Android e fai clic su OK.
Eclipse proverà a eseguire l'applicazione sul dispositivo Android. Al momento, però, non hai dispositivi Android, quindi il progetto fallirà e ti verrà chiesto di creare un nuovo dispositivo virtuale Android (AVD).
Dispositivi virtuali (dispositivi virtuali Android)
Android Virtual Device (AVD) emula l'ambiente Android, sia esso un telefono cellulare o un tablet PC. Puoi creare tutti i dispositivi AVD che desideri, con diverse versioni della piattaforma Android. Per ogni AVD, puoi configurare varie impostazioni del dispositivo come tastiera fisica, supporto GP, risoluzione della fotocamera e così via.
Prima di eseguire l'applicazione, è necessario creare il primo dispositivo AVD con l'SDK della piattaforma (Google API, 1.6).
Facciamolo adesso:
- Se non hai ancora provato a eseguire l'applicazione, premi Esegui (o la scorciatoia da tastiera Ctrl+F11)
- Quando viene visualizzato l'avviso, fare clic su Sì per creare l'AVD.
- Fare clic su Nuovo nella finestra di dialogo di Android SDK e AVD Manager.
- Impostare i seguenti parametri per AVD: Nome: Android_1.6 Destinazione: API di Google (Google Inc.) - API livello 4 Dimensioni scheda SD: 16 MiB Skin Integrata: predefinita (HVGA)
- Fare clic su Crea AVD.
- Chiudi la finestra di dialogo di Android SDK e AVD Manager.
Codice in esecuzione
Prova a eseguire nuovamente l'applicazione (Ctrl + F11). Eclipse creerà ora il tuo progetto e lancerà il nuovo AVD. Ricorda, AVD emula completamente l'ambiente Android e non devi nemmeno guardare il processo di avvio lento come faresti con un dispositivo reale. Per questo motivo, una volta che l'AVD è pronto per l'uso, è meglio non chiudere la finestra fino al termine della programmazione, durante la giornata.
Sviluppo Android: progettazione dell'interfaccia utente
Uno dei primi passi per creare qualsiasi programma è la progettazione dell'interfaccia utente. Ecco un piccolo schizzo della nostra applicazione:
L'utente potrà impostare il tempo di ebollizione in minuti utilizzando i pulsanti + e -. Quando preme Start, il conto alla rovescia inizierà per il numero di minuti specificato. Se l'utente annulla l'ebollizione premendo nuovamente il pulsante, il tempo verrà esteso quando il timer raggiunge lo 0.
Costruzione dell'interfaccia
L'interfaccia utente di Android, o skin, descritta nella documentazione XML, si trova nella cartella res/layouts. Il codice del template, già generato da Eclipse, è dichiarato in res/layouts/main.xml e, come puoi vedere, è già in esecuzione nell'emulatore.
Eclipse ha il suo strumento di progettazione del layout che ti consente di creare un'interfaccia trascinando e rilasciando all'interno dello schermo. Tuttavia, a volte è più semplice scrivere l'interfaccia in XML e utilizzare un layout grafico per visualizzare in anteprima i risultati.
Facciamolo ora modificando main.xml in modo che corrisponda allo schizzo sopra:
- Apri res/layouts/main.xml in Eclipse facendo doppio clic da Package Explorer.
- Seleziona la scheda main.xml nella parte inferiore dello schermo per passare alla modalità XML.
Ora cambiamo il contenuto di main.xml nel seguente:
# /res/layouts/main.xml
Come puoi vedere, ci sono molti file in Android XML, ma questo ti permetterà di controllare quasi tutti gli elementi sullo schermo.
Uno degli elementi più importanti dell'interfaccia utente in Android sono i contenitori di layout come LinearLayout usato in questo esempio. Questi elementi sono invisibili all'utente ma fungono da contenitori per altri elementi come Buttons e TextViews.
Esistono diversi tipi di layout di layout, ognuno dei quali viene utilizzato per creare diversi tipi di layout. Come LinearLayout e AbsoluteLayout, TableLayout consente un'interfaccia basata su griglia. Puoi saperne di più nella sezione Layout generale degli oggetti della documentazione dell'API.
Collegamento del layout al codice
Dopo aver salvato il layout, prova a eseguire l'applicazione nell'emulatore premendo Ctrl + F11 o facendo clic sull'icona Esegui in Eclipse. Ora, invece del messaggio "Hello World", vedrai che Android ora mostra l'interfaccia dell'applicazione.
Se si preme un pulsante, si accendono come previsto, ma non si fa altro. Continuiamo a codificare dopo l'interfaccia di layout:
# /src/com/example/brewclock/BrewClockActivity.java ... importa android.widget.Button; importa android.widget.TextView; public class BrewClockActivity estende l'attività ( /** Proprietà **/ pulsante protetto brewAddTime; pulsante protetto brewDecreaseTime; pulsante protetto startBrew; TextView protetto brewCountLabel; TextView protetto brewTimeLabel; ... )
Successivamente, cambieremo la chiamata in onCreate. Questa chiamata si verifica ogni volta che viene avviata un'applicazione su Android. Nel codice generato da Eclipse, onCreate crea una vista attività su R.layout.main. Questa è la riga di codice che indica ad Android di decodificare il layout del documento XML e mostrarlo all'utente.
Oggetto risorsa
In Android, R è un oggetto speciale che viene creato automaticamente per fornire l'accesso alle risorse del tuo progetto (layout, stringhe, menu, icone...) all'interno del codice. Ad ogni risorsa viene assegnato il proprio ID. Nel file di layout (vedi sopra) questi sono gli attributi @+id XML. Li useremo per associare pulsanti e TextView nel nostro layout:
# /src/com/example/brewclock/BrewClockActivity.java ... la classe pubblica BrewClockActivity estende l'attività ( ... public void onCreate(Bundle saveInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.main); / / Collega gli elementi dell'interfaccia alle proprietà brewAddTime = (pulsante) findViewById(R.id.brew_time_up); brewDecreaseTime = (pulsante) findViewById(R.id.brew_time_down); startBrew = (pulsante) findViewById(R.id.brew_start); brewCountLabel = (TextView) findViewById(R.id.brew_count_label); brewTimeLabel = (TextView) findViewById(R.id.brew_time); ) )
Ascolto di eventi
Per rilevare le pressioni dei pulsanti, è necessario implementare un listener per loro. Potresti avere familiarità con i callback listener, o callback, da altri framework come Javascript/JQuery o Rails.
Android fornisce un meccanismo simile fornendo un'interfaccia Listener, ad esempio OnClickListener , che definisce i metodi che verranno attivati quando si verifica l'evento. L'interfaccia di OnClickListener avviserà la tua applicazione quando l'utente fa clic sullo schermo o su un pulsante specifico. Inoltre, devi indicare a ciascun pulsante il ClickListener:
# /src/com/example/brewclock/BrewClockActivity.java ... // Assicurati di non importare // `android.content.dialoginterface.OnClickListener`. importare android.view.View.OnClickListener; public class BrewClockActivity estende Activity implementa OnClickListener ( ... public void onCreate(Bundle saveInstanceState) ( ... // Setup ClickListeners brewAddTime.setOnClickListener(this); brewDecreaseTime.setOnClickListener(this); startBrew.setOnClickListener(this); ) .. .public void onClick(View v) ( // TODO: Aggiungi codice per gestire i tocchi dei pulsanti ) )
Successivamente, aggiungeremo il codice che gestisce ciascuna delle nostre pressioni di pulsanti. Aggiungeremo anche quattro nuove proprietà dell'attività che consentiranno all'utente di impostare e tenere traccia del tempo di infusione: quante birre sono state fatte e se il timer è stato avviato.
# /src/com/example/brewclock/BrewClockActivity.java ... la classe pubblica BrewClockActivity estende l'attività implementa OnClickListener ( ... protected int brewTime = 3; protected CountDownTimer brewCountDownTimer; protected int brewCount = 0; protected boolean isBrewing = false; . .. public void onClick(View v) ( if(v == brewAddTime) setBrewTime(brewTime + 1); else if(v == brewDecreaseTime) setBrewTime(brewTime -1); else if(v == startBrew) ( if( isBrewing) stopBrew(); else startBrew(); ) ) )
Nota che stiamo usando la classe CountDownTimer fornita da Android. Ciò semplifica la creazione e l'esecuzione di un semplice contatore e la ricezione di notifiche a intervalli regolari durante il conto alla rovescia. Lo userai nel metodo startBrew, leggilo di seguito.
I metodi seguenti sono modelli per il comportamento del dispositivo di scorrimento per l'impostazione del tempo di infusione, di avvio e arresto dell'infusione e del contatore. Inizializzeremo anche le proprietà brewTime e brewCount in onCreate.
Sarebbe buona norma spostare questo codice in una classe modello separata, ma per semplicità aggiungeremo il codice a BrewClockActivity:
# /src/com/example/brewclock/BrewClockActivity.java ... la classe pubblica BrewClockActivity estende l'attività implementa OnClickListener ( ... public void onCreate(Bundle saveInstanceState) ( ... // Imposta i valori iniziali della birra setBrewCount(0 ); setBrewTime(3); ) /** * Imposta un valore assoluto per il numero di minuti per l'erogazione. * Non ha effetto se un'infusione è attualmente in esecuzione. * @param minutes Il numero di minuti per l'erogazione. */ public void setBrewTime( int minutes) ( if(isBrewing) return; brewTime = minuti; if(brewTime< 1) brewTime = 1; brewTimeLabel.setText(String.valueOf(brewTime) + "m"); } /** * Set the number of brews that have been made, and update * the interface. * @param count The new number of brews */ public void setBrewCount(int count) { brewCount = count; brewCountLabel.setText(String.valueOf(brewCount)); } /** * Start the brew timer */ public void startBrew() { // Create a new CountDownTimer to track the brew time brewCountDownTimer = new CountDownTimer(brewTime * 60 * 1000, 1000) { @Override public void onTick(long millisUntilFinished) { brewTimeLabel.setText(String.valueOf(millisUntilFinished / 1000) + "s"); } @Override public void onFinish() { isBrewing = false; setBrewCount(brewCount + 1); brewTimeLabel.setText("Brew Up!"); startBrew.setText("Start"); } }; brewCountDownTimer.start(); startBrew.setText("Stop"); isBrewing = true; } /** * Stop the brew timer */ public void stopBrew() { if(brewCountDownTimer != null) brewCountDownTimer.cancel(); isBrewing = false; startBrew.setText("Start"); } ... }
Solo le parti specifiche di Android di questo codice creano visualizzazioni di etichette utilizzando il metodo setText. In startBrew creiamo ed eseguiamo un CountDownTimer per iniziare il conto alla rovescia al secondo quando l'infusione/bollitura è finita. Nota che stiamo definendo i listener CountDownTimer (onTick e onFinish). onTick verrà chiamato ogni 1000 millisecondi (1 secondo), mentre onFinish viene chiamato quando il timer raggiunge lo zero.
Evitare la complessità nella programmazione Android
Per mantenere semplice questa guida allo sviluppo di Android, ho utilizzato intenzionalmente delle etichette direttamente nel codice (ad es. "Brew Up!", "Start", "Stop"). In realtà, questa non è una buona pratica, poiché rende difficile trovare e modificare queste linee nei grandi progetti.
Android fornisce un modo semplice per mantenere le stringhe di testo separate dal codice dell'oggetto R. R consente di definire tutte le stringhe dell'applicazione in un file XML (res/values/strings.xml) a cui è possibile accedere nel codice per riferimento. Per esempio:
# /res/valori/stringhe.xml
Ora se vuoi cambiare Brew Up! qualcos'altro, devi cambiarlo una volta nel file strings.xml. Se la tua app contiene dozzine di file di codice, avere etichette in un unico posto ha molto senso!
Controllo BrewClock
Abbiamo finito di scrivere il codice ed è ora di "testare" l'applicazione. Premi "Esegui" o Ctrl + F11 per eseguire BrewClock nell'emulatore. Se tutto è andato bene, vedrai l'interfaccia di configurazione e sarai pronto per preparare il tè! Prova a impostare tempi di infusione diversi e premi Avvia per il conto alla rovescia.
Riepilogo
In questa breve introduzione allo sviluppo di Android, hai scaricato e installato l'SDK Android e il plug-in Eclipse Android Development Tools (ADT). Hai configurato un emulatore o un dispositivo virtuale per testare le tue applicazioni. Hai anche creato un'applicazione Android funzionante che ha evidenziato una serie di concetti chiave , che utilizzerai durante lo sviluppo di future applicazioni Android.
Si spera che questo stuzzichi il tuo appetito per la creazione di app mobili e la sperimentazione in questa entusiasmante area. Android offre un ottimo modo per scrivere app per una gamma di dispositivi mobili attuali e futuri. Se hai già scritto un'applicazione funzionante per questa piattaforma, non dimenticare di farcelo sapere nei commenti!
L'IDE Eclipse consente di gestire, modificare, compilare, eseguire ed eseguire il debug delle applicazioni. Il plug-in ADT per Eclipse fornisce agli utenti strumenti aggiuntivi utilizzati per sviluppare applicazioni Android. Puoi anche utilizzare il plug-in ADT per gestire diverse versioni della piattaforma Android. Ciò è necessario quando si sviluppano applicazioni per dispositivi diversi che eseguono versioni diverse del sistema operativo Android. Dopo aver avviato l'ambiente Eclipse per la prima volta, apparirà la scheda Benvenuto:
In questa scheda sono presenti una serie di link-icone cliccando sui quali verrai indirizzato alle sezioni corrispondenti.
Fare clic sul pulsante Workbench per visualizzare prospettiva Sviluppo Java, dove inizia lo sviluppo di applicazioni Android. Eclipse supporta lo sviluppo di applicazioni in diversi linguaggi di programmazione. Ogni toolbox Eclipse installato è rappresentato da un separato
prospettiva di sviluppo.
Crea un nuovo progetto
Per avviare la programmazione Android in Eclipse, esegui i comandi File->NewProject... per visualizzare la finestra di dialogo Nuovo progetto
Questa finestra può essere visualizzata anche utilizzando l'elenco a discesa Nuovo sulla barra degli strumenti.
Espandi il nodo Android, seleziona l'opzione Progetto applicazione Android e fai clic sul pulsante Avanti>. Sullo schermo apparirà la finestra di dialogo Nuovo progetto Android.
Progettoè un gruppo di file correlati, come file di codice e di immagine, che formano un'applicazione. Nella finestra di dialogo Nuovo progetto, puoi creare un progetto da zero o utilizzare il codice sorgente esistente (ad esempio, il codice di un libro o gli esempi forniti con l'SDK di Android).
A proposito, la finestra Nuova applicazione Android è cambiata molto, iniziando con il nome e finendo con il contenuto. Quindi lo scopriremo man mano che il gioco procede.
E allora andiamo! Compila i campi come mostrato nello screenshot
Nome dell'applicazione- questo è il nome che verrà visualizzato nel PlayStore, nonché nel gestore applicazioni sul dispositivo su cui verrà installata l'applicazione.
Nome del progetto- nome del progetto utilizzato solo in Eclissi. Deve essere unico nell'ambiente di produzione. Di solito è lo stesso del nome dell'applicazione, ma l'ho reso diverso per chiarire dove verrà visualizzato il nome.
Nome del pacchetto- questo nome DEVE ESSERE un ID UNICO per la tua applicazione. Cioè, devi essere sicuro che nessun altro chiamerà la loro applicazione in quel modo. E questo nome deve rimanere lo stesso per tutta la vita dell'applicazione (le versioni dell'applicazione possono cambiare, ma il nome deve rimanere lo stesso).
SKD minimo richiesto– la versione minima di Android richiesta per il funzionamento della tua applicazione. Ciò significa essenzialmente la versione minima dell'SDK necessaria per il corretto funzionamento dell'applicazione. Inoltre, Android semplicemente non ti consentirà di installare l'applicazione se il dispositivo ha una versione Android con un numero API inferiore a quello specificato in questo parametro.
SDK di destinazione- la versione di destinazione o massima di Android su cui l'applicazione funzionerà sicuramente ed è stata testata. Si consiglia di impostare questo parametro il più alto possibile.
Compila l'SDK– versione dell'SDK da te installato con cui verrà compilata l'applicazione.
tema- tema di progettazione dell'applicazione.
In linea di principio, una descrizione dettagliata di tutti questi articoli è in lingua borghese ed è disponibile passando il mouse sopra l'icona blu con una lettera io.
Quindi fai clic su Avanti e vedi la finestra seguente
Rimuovere la casella di controllo da Crea un'icona di avvio personalizzata premiamo Prossimo
Selezionare Attività vuota e fare clic su Avanti e vedere la finestra seguente
Compiliamo come sullo schermo e clicchiamo su Fine e vediamo la prospettiva di sviluppare un progetto Java
In giallo, ho evidenziato a cosa dovresti prestare particolare attenzione, in modo che diventi chiaro dove sono rimasti i nomi. Quindi, espandi il nodo, quindi il nodo layout e fai doppio clic su main.xml e lo ed ecco! Vediamo come sarà la nostra applicazione! Facendo clic su main.xml abbiamo invocato l'editor di layout visivo ADT. Con esso, puoi creare un'interfaccia utente grafica trascinando i componenti della GUI come pulsanti, TextViews, ImageViews, ecc. nella finestra dell'applicazione.
Riconfiguriamo un po' il nostro ambiente in modo che tutto possa essere visto meglio.
Il nodo del progetto organizza il contenuto del progetto in vari file e cartelle, tra cui:
src- una cartella contenente i file sorgente del progetto Java;
gene- una cartella contenente i file Java generati dall'IDE;
Android 2.3.3— una cartella contenente la versione del framework Android selezionata in fase di creazione dell'applicazione;
ris- Una cartella che contiene i file di risorse associati all'applicazione, come i layout della GUI e le immagini utilizzate nell'applicazione.
altre cartelle verranno discusse in seguito.
Quando crei un'applicazione Android con Eclipse, il layout dell'interfaccia utente viene archiviato in un file XML, denominato main.xml per impostazione predefinita. Definendo gli elementi della GUI in un file XML, puoi facilmente separare la logica di un'applicazione dalla sua presentazione. I file di layout sono risorse dell'applicazione e sono archiviati nella cartella res del progetto. I layout della GUI si trovano in una sottocartella della cartella del layout.
Per visualizzare il contenuto XML del file, selezionare la scheda con il nome del file di layout (in questo caso main.xml). Per tornare alla visualizzazione Editor layout visivo, selezionare la scheda Layout grafico.
In linea di principio, questa applicazione può già essere avviata per l'esecuzione. L'ho eseguito usando Genymotion in quanto è molto più veloce dell'emulatore Android dell'SDK e persino di Intel.
Video utile su questo argomento
E così continuiamo a sperimentare con il nostro primo progetto.
Eliminazione e ricreazione del file main.xml
Durante la creazione dell'applicazione per questo capitolo, verrà utilizzato un nuovo file di layout, RelativeLayout, al posto del file main.xml predefinito (questo file definisce la posizione relativa dei componenti). Per sostituire il file main.xml predefinito, procedere come segue:
1) Assicurati che il file main.xml sia chiuso, quindi fai clic con il pulsante destro del mouse su di esso (nella cartella /res/layout del progetto) e seleziona il comando Elimina per eliminare il file.
2) Nel nodo Android, selezionare l'opzione File di layout XML Android e fare clic su Avanti
4) Assicurati che il file sia stato creato nella directory /res/layout
E fai clic su Fine ed entra nella finestra già familiare
Regolazione delle dimensioni e della risoluzione dello schermo nell'editor di layout visivo
Poiché il sistema operativo Android può essere eseguito su molti dispositivi diversi, Visual Layout Editor viene fornito con diverse configurazioni di dispositivi che rappresentano dimensioni e risoluzioni dello schermo diverse. Queste impostazioni sono selezionate dall'elenco a discesa Configurazioni dispositivo.
Se le configurazioni predefinite non corrispondono al dispositivo per il quale si sta sviluppando l'applicazione, è possibile creare la propria configurazione del dispositivo da zero, oppure copiando e modificando una delle configurazioni esistenti.
Per creare gli esempi del libro, abbiamo utilizzato il principale dispositivo di prova Samsung Nexus S, che è dotato di uno schermo da 4 pollici con una risoluzione di 480×800 pixel (WVGA). Si consiglia di sviluppare una libreria GUI Android scalabile che renderà correttamente le immagini sugli schermi di vari dispositivi. A causa della proprietà di scalabilità, l'area di progettazione dell'editor di layout visivo non deve necessariamente corrispondere esattamente agli schermi dei dispositivi fisici. È sufficiente selezionare una configurazione simile del dispositivo.
Dimensioni e risoluzione delle immagini e dello schermo
Poiché gli schermi dei dispositivi Android hanno dimensioni dello schermo, risoluzioni e densità di pixel dello schermo diverse (espresse in punti per pollice o DPI), le immagini supportate (e altre risorse) vengono selezionate dal sistema operativo in base alla densità dei pixel dello schermo del dispositivo. Pertanto, nella cartella ris Il progetto ha quattro sottocartelle:
drawable-xhdpi(densità ultra alta)
hdpi disegnabile(alta densità)
drawable-mdpi(media densità)
drawable-ldpi(bassa densità)
Densità di pixel del dispositivo Android
xhdpi Ultra alta densità - ca. 320
dpi
hdpi Alta densità - ca. 240
dpi
mdpi La densità media è di ca. 160
dpi
ldpi Bassa densità - ca. 120
dpi
nodpi Nessun ridimensionamento delle risorse indipendentemente dalla densità dello schermo
Passaggio 1. Aggiunta di immagini al progetto
Per questa applicazione, è necessario aggiungere al progetto le immagini del bug Deitel (bug.png) e del logo Android (android.png). Queste immagini si trovano nella cartella delle immagini insieme agli esempi di libri. Per aggiungere immagini a un progetto, procedi come segue:
1. Nella finestra Package Explorer, aprire la cartella del progetto res.
2. Individua e apri la cartella delle immagini che si trova tra gli esempi nel libro, quindi trascina e rilascia le immagini nella cartella situata nella sottocartella drawable-hdpi della cartella res.
Le immagini possono ora essere utilizzate nell'applicazione.
Passaggio 2. Modificare la proprietà Id di RelativeLayout
Utilizzando la finestra Proprietà, è possibile configurare le proprietà del layout o del componente selezionato senza modificare direttamente il codice XML. Se la finestra Proprietà non è visibile, visualizzarla facendo doppio clic sulla voce RelativeLayout nella finestra Struttura.
Seleziona il componente RelativeLayout, quindi scorri la finestra Proprietà per selezionare la proprietà Id e assegnale un valore:
@+id/benvenutoRelativeLayout
Il nome di ogni oggetto è determinato dalla sua proprietà Id. Questa proprietà può essere utilizzata per accedere e modificare un componente senza doverlo fare
conoscere la posizione esatta del componente nel codice XML. Come verrà mostrato in seguito, la proprietà Id può essere utilizzata anche per indicare il posizionamento relativo dei componenti in un RelativeLayout.
Simbolo +
In costruzione @+id definisce la creazione di un nuovo identificatore (nome variabile), che viene specificato a destra del simbolo /
Passaggio 3: imposta la proprietà di sfondo di RelativeLayout su un valore
Per impostazione predefinita, il colore di sfondo del layout è bianco (nel nostro caso), ma puoi cambiarlo (ad esempio, in giallo). Qualsiasi colore è il risultato della miscelazione di componenti rossi, blu e verdi, chiamati componenti RGB. Ciascuno di questi componenti può assumere un valore intero compreso tra 0 e 255. Il primo componente specifica la quantità di rosso nel colore complessivo, il secondo specifica la quantità di verde e il terzo specifica la quantità di blu. Durante l'esecuzione nell'ambiente di sviluppo integrato (IDE), il colore viene specificato in formato esadecimale. Cioè, i componenti RGB sono rappresentati come valori nell'intervallo 00–FF.
Per modificare il colore di sfondo, trova la proprietà Sfondo nella finestra Proprietà e impostala su #FFFF33
Il formato #RRGGBB è costituito da coppie di numeri esadecimali che rappresentano rispettivamente rosso, verde e blu. Android supporta anche i valori alfa (trasparenza) che vanno da 0-255. Un valore di 0 è completamente trasparente e un valore di 255 è completamente opaco. Se prevedi di utilizzare valori alfa, specifica il colore nel formato #AARRGGBB, dove le prime due cifre esadecimali corrispondono al valore alfa.
Se entrambe le cifre di ciascun componente di colore sono uguali, puoi utilizzare il formato #RGB o #ARGB. Ad esempio, il valore #FFF viene trattato come #FFFFFF.
Passaggio 4: aggiunta di un componente TextView
In questo passaggio, aggiungeremo un componente TextView all'interfaccia utente. Nell'elenco Form Widgets (Form Widgets), che si trova sul lato sinistro della finestra Visual Layout Editor, trova il componente TextView e trascinalo nell'area di progettazione 
Dopo aver aggiunto un nuovo componente all'interfaccia utente, questo viene selezionato automaticamente e le sue proprietà vengono visualizzate nella finestra Proprietà.
Passaggio 5: impostare la proprietà del testo del componente TextView utilizzando le risorse di stringa
Secondo la documentazione Android sulle risorse dell'applicazione (developer.android.com/guide/topics/resources/index.html), è considerata buona pratica archiviare stringhe, array di stringhe, immagini, colori, dimensioni dei caratteri, dimensioni e altre applicazioni risorse in un modo che può essere utilizzato separatamente dal codice dell'applicazione. Ad esempio, dopo aver esternalizzato i valori di colore, tutti i componenti che utilizzano lo stesso colore possono essere ricolorati semplicemente modificando il valore del colore nel file di risorse centrale.
Se devi localizzare le applicazioni creando versioni in diverse lingue, mantieni le stringhe separate dal codice dell'applicazione. Di conseguenza, sarai in grado di modificare facilmente queste linee in futuro. La cartella res del progetto contiene la sottocartella dei valori, che contiene il file strings.xml. Questo file viene utilizzato per memorizzare le stringhe. Per generare stringhe localizzate per altre lingue, crea cartelle di valori separate per ciascuna lingua che utilizzi.
Ad esempio, la cartella values-fr potrebbe contenere un file strings.xml per il francese e la cartella values-es potrebbe contenere un file strings.xml per lo spagnolo. Puoi anche formare i nomi di queste cartelle in base alle informazioni sulla regione. Ad esempio, la cartella values-en-US potrebbe contenere un file strings.xml per l'inglese americano e la cartella values-en-GB potrebbe contenere un file strings.xml per l'inglese britannico.
Per ulteriori informazioni sulla localizzazione, vedere le risorse:
developer.android.com/guide/topics/resources/;
fornitura-risorse.html.AlternativeResources;
developer.android.com/guide/topics/resources/localization.html.
Per impostare il valore della proprietà Text del componente TextView, creiamo una nuova risorsa stringa nel file strings.xml.
1. Selezionare il componente TextView.
2. Nella finestra Proprietà, trovare la proprietà Testo, fare clic sul valore predefinito, quindi fare clic sul pulsante con i puntini di sospensione. Questo pulsante è sulla destra
parte del campo del valore della proprietà e visualizza la finestra di dialogo Selezione risorse.
3. Nella finestra di dialogo Selezione risorse, fare clic sul pulsante Nuova stringa... per visualizzare la finestra di dialogo Crea nuova stringa Android.
stringa Android)
4. Compila i campi Stringa e Nuova stringa R, quindi fai clic sul pulsante OK per nascondere la finestra di dialogo Crea nuova stringa Android e tornare alla finestra Selezione risorse.
5. Viene selezionata automaticamente una nuova risorsa stringa di benvenuto. Fare clic sul pulsante OK per selezionare questa risorsa.
Dopo aver completato i passaggi precedenti, la proprietà Testo viene visualizzata nella finestra Proprietà. Una voce nel formato @string indica che una risorsa stringa esistente può essere selezionata nel file strings.xml e il nome welcome indica che una risorsa stringa è attualmente selezionata.
Il vantaggio principale della definizione di valori di stringa è quello di facilitare la localizzazione dell'applicazione creandone altri
File di risorse XML per altre lingue. Ogni file utilizza lo stesso nome nel campo New R.string e supporta una stringa internazionalizzata nel campo String. Android può quindi selezionare il file di risorse appropriato in base alla lingua preferita dell'utente del dispositivo. Per ulteriori informazioni sulla localizzazione, visita developer.android.com/guide/topics/resources/localization.html.
Passaggio 6: imposta la dimensione del testo e le proprietà del riempimento superiore del componente TextView su Densità e scala pixel indipendenti
I componenti della GUI e il testo su uno schermo Android possono essere ridimensionati utilizzando diverse unità di misura.
La documentazione che descrive le varie dimensioni dello schermo è disponibile all'indirizzo developer.android.com/guide/practices/screens_support.html e consiglia di utilizzare pixel indipendenti dalla densità per il dimensionamento dei componenti della GUI e di altri elementi dello schermo e le dimensioni dei caratteri impostate utilizzando pixel indipendenti dal ridimensionamento.
La specifica delle dimensioni dei pixel indipendenti dalla densità (dp o dip) consente alla piattaforma Android di ridimensionare automaticamente la GUI in base alla densità dei pixel dello schermo del dispositivo fisico.
La dimensione di un pixel indipendente dalla densità è equivalente alla dimensione di un pixel fisico su uno schermo a 160 dpi (punti per pollice). Sulla risoluzione dello schermo
Una dimensione del pixel indipendente dalla densità di 240 dpi verrà ridimensionata di un fattore di 240/160 (ovvero 1,5). Pertanto, un componente che è di 100 pixel indipendenti dalla densità verrà ridimensionato a una dimensione di 150 pixel fisici su tale schermo. Su uno schermo a 120 dpi, ogni pixel indipendente dalla densità viene ridimensionato di un fattore 120/160 (ovvero 0,75). Ciò significa che 100 pixel indipendenti dalla densità si trasformeranno in 75 pixel fisici su uno schermo del genere. I pixel indipendenti dalla scala vengono ridimensionati allo stesso modo dei pixel indipendenti dalla densità, ma la loro scala dipende anche dalla dimensione del carattere preferita dell'utente.
Ora aumentiamo la dimensione del carattere per il componente TextView e aggiungiamo un po' di riempimento sopra il componente TextView.
1. Per modificare la dimensione del carattere, selezionare TextView e quindi impostare la proprietà Dimensione del testo su 40sp.
2. Per aumentare il margine tra il bordo superiore del layout e la TextView, selezionare la proprietà Margine superiore del layout nella sezione Varie della finestra Proprietà
e assegnagli un valore di 10 dp.
Passaggio 7. Impostazione di proprietà aggiuntive del componente TextView
Configurare le proprietà aggiuntive del componente TextView come segue:
1. Impostare la proprietà Id su @+id/welcomeTextView.
2. Impostare la proprietà Colore del testo su #00F(blu).
3. Impostare la proprietà Stile testo su grassetto. Per eseguire questa operazione, fare clic nel campo Valore di questa proprietà, quindi fare clic sul pulsante con i puntini di sospensione per visualizzare una finestra di dialogo in cui si seleziona uno stile di carattere. Seleziona la casella in grassetto, quindi fai clic sul pulsante OK per selezionare uno stile di testo.
4. Per centrare il testo del componente TextView quando si estende su più righe, impostare la proprietà Gravità su centrato. Per l'esecuzione
per questa operazione, fare clic nell'area del campo Valore di questa proprietà, quindi fare clic sul pulsante con i puntini di sospensione per visualizzare la finestra di dialogo delle impostazioni della proprietà
gravità 
Passaggio 8 Visualizza i loghi dei bug Android e Deitel con ImageViews
1. Trascinare il componente ImageView, che si trova nella categoria Immagini e media (Immagini e risorse multimediali) della tavolozza Editor layout visivo, nella finestra Struttura (Layout), . Un nuovo componente ImageView apparirà sotto il nodo welcomeTextView.
2. Impostare la proprietà Id del componente ImageView su @+id/droidImageView. Il nome dell'oggetto droidImageView verrà visualizzato nella finestra Outline.
3. Impostare la proprietà Layout center horizontal di droidImageView su true per centrare ImageView all'interno del layout.
4. Impostare il campo Descrizione contenuto su @string/droidPic
5. Facciamo azioni simili per l'immagine bug.png. Imposta la proprietà Id del componente su @+id/bugImageView.
Bene, lanciamo la nostra prima applicazione :)
Oggi c'era un compito: configurare Eclipse per lo sviluppo Android.
Saranno richieste le seguenti cose:
- Eclipse (io ho usato Classic)
- Strumenti per sviluppatori Android (ADT)
- SDK Android
La prima cosa di cui hai bisogno è un ambiente di sviluppo (IDE). Su Android, è Eclipse. Puoi scaricare dal sito ufficiale: http://www.eclipse.org/downloads/ (Scarica in base al bit del sistema operativo installato sul computer). È fantastico che Eclipse sia disponibile per Windows, Linux e Mac. Inoltre è gratuito. Eclipse non è installato: basta scaricarlo e decomprimerlo su un disco in una cartella separata (è meglio creare una cartella da qualche parte senza lettere russe nel nome)
Il JDK è necessario per il funzionamento di Eclipse e Java. Può essere scaricato dal sito Web di Oracle. La versione JRE sarà sufficiente.
Si aprirà una finestra in cui dovrai specificare l'URL del server in cui si trova il pacchetto. Google ha il seguente indirizzo: https://dl-ssl.google.com/android/eclipse/, quindi devi controllare tutti gli elementi in Strumenti per sviluppatori e fare clic su Avanti
La procedura guidata installerà ADT. Successivamente, dovrai riavviare Eclipse.
Successivamente, devi andare a scaricare l'SDK Android. Puoi farlo sul sito ufficiale. Devi scaricare esattamente bin: è più conveniente. Successivamente, è necessario collegare l'SDK e Eclipse:
Vai su Finestra -> Preferenze -> Android
Specificare la posizione in cui è stato installato l'SDK nel campo di testo Posizione SDK. Per impostazione predefinita è: C:\Programmi (x86)\Android\android-sdk
L'ultimo passaggio consiste nell'aggiornare proprio questo SDK. Vai a Finestra -> Gestione SDK Android. Si aprirà una finestra come questa (ho già installato tutto):
In senso positivo, qui puoi selezionare tutti i pacchetti e fare clic sul pulsante Installa pacchetti. E puoi andare a bere un caffè. Il processo richiederà più di un'ora. Per alcuni pacchetti non di Google, mi è stata chiesta una password - rifiutiamo e saltiamo - funzionerà comunque.
