Scarica Android e più Appunti in PDF di Elementi di Informatica solo su Docsity!
Android
Android sta dilagando. Non è più solo questione di smartphone o tablet. Si sta imponendo come sistema operativo in grado di animare qualsiasi dispositivo più o meno mobile tanto da apparire, in prospettiva non troppo futuristica, una presenza sempre più costante nel nostro quotidiano.
Gli è stata attribuita – e probabilmente a ragione – la più veloce diffusione mai vista per un sistema operativo mobile. Ma quali sono i fattori di questo successo e soprattutto perchè tutto ciò sta capitando ad Android? Le motivazioni ipotizzate sono varie e di varia natura. Gran parte del merito è stato attribuito alle sue radici ben salde nel mondo open source. Android, infatti, è figlio di Linux, ha attirato l’interesse di tanti sviluppatori che per anni si sono stretti intorno ai grandi bacini del software libero ed accoglie in sé tutto il meglio di quanto è stato ideato per supportare lo sviluppo del web, desktop e mobile sia in termini di pattern progettuali che di librerie software.
Eppure architettura del sistema ed open source sono aspetti che interessano molto una platea fortemente tecnica come programmatori ed ingegneri informatici. Per decretare un successo tanto ampio è necessario che ci sia anche un forte riscontro di pubblico. Sicuramente un qualcosa che ha contraddistinto questo sistema è stata la sua adozione da parte di dispositivi molto diversi tra loro, non solo per tipologia – smartphone piuttosto che tablet – ma soprattutto per fasce di prezzo, da poche decine di euro fino a cifre piuttosto significative.
Ciò ne ha permesso una diffusione molto diverficata trasversalmente alle diverse categorie sociali, ma ha causato di riflesso una frammentazione notevole dello scenario applicativo costringendo gli sviluppatori ad una particolare cura degli aspetti di adattamento alle caratteristiche del dispositivo ospite. Proprio in questo, Android ha dimostrato la sua grande modernità offrendo tutto il supporto necessario per permettere all’applicazione in esecuzione di adegursi ad ogni circostanza.
Questa guida è dedicata allo sviluppo di applicativi Android. Nella prossime lezioni verrà utilizzata una programmazione in linguaggio Java per realizzare applicazioni in cui non manca niente. Si creeranno interfacce utente interattive, dinamiche e graficamente piacevoli. Si avranno gli strumenti per gestire dati e avviare attività di rete in modo che le proprie app prendano da subito parte a quel grande laboratorio di idee che è Internet e tutti i servizi che ne fanno parte. Ed inoltre si avrà a disposizione multimedialità, funzionalità hardware, comunicazione.
Per iniziare, Android richiede nozioni di programmazione Java, passione, curiosità e nulla più. Infatti gli strumenti che si renderanno necessari, come si vedrà presto, sono totalmente gratuiti. Quindi non ci sono scuse per non cominciare.
L’SDK e l’ambiente di sviluppo
Per iniziare a programmare su Android abbiamo bisogno di alcuni strumenti software, tutti reperibili su Internet a costo zero. Ci serviranno:
- un JDK , il kit di sviluppo per la tradizionale programmazione Java, visto che questa è la tecnologia con cui realizzeremo i nostri programmi;
- un IDE (ambiente di sviluppo integrato) che includa possibilmente tutti gli strumenti necessari al programmatore. Ne vedremo due: Android Studio , la soluzione ufficiale e quindi preferibile, ed Eclipse , sempre meno utilizzato ma che gode ancora di un folto bacino di utenza.
Tra gli strumenti appena citati, di cui a breve verranno illustrate le fasi di download ed installazione, non è stato nominato un elemento fondamentale che merita, però, una menzione speciale: l’ Android SDK. Questo è il vero pacchetto di strumenti che ci permetterà di vedere realizzati i nostri programmi per Android. Nonostante l’importanza fondamentale rivestita, il suo utilizzo, inizialmente, può passare un po’ inosservato visto che vi si interagisce spesso tramite l’IDE. Per questo non mancheremo di sottolinearne sin da ora la sua struttura e le funzionalità che ne fanno parte.
Iniziamo, se non lo si è già fatto, ad insallare Java. È necessario recarsi presso il sito Oracle e scaricarne una versione per il proprio sistema operativo, specificando non solo la tipologia – Windows, Linux, Mac OS o Solaris – ma anche la versione, 32 o, meglio se se ne ha la possibilità, 64 bit. Una volta eseguito lo scaricamento del pacchetto se ne procede all’installazione che non presenta grandi difficoltà in alcuno dei sistemi per cui è disponibile.
Passiamo ora agli IDE.
Android Studio
Nonostante la prima generazione di sviluppatori Android si sia formata su Eclipse, la nascita di Android Studio e la sua raggiunta maturità sono stati salutati con gioia dagli addetti ai lavori. Infatti questo ambiente – ottenibile dal sito ufficiale di Android – è venuto al mondo sotto i migliori auspici, all’insegna della flessibilità e della praticità. Innanzitutto, è figlio di IntelliJ, un IDE molto intuitivo ed efficiente prodotto dalla società JetBrains. In secondo luogo, è scaturito dalla stessa Google e nasce appositamente per Android, integrandosi con tutto il suo ecosistema. Permette di realizzare progetti per smartphone e tablet, nonchè per dispositivi indossabili, Android Auto e Android TV. Il colosso di Mountain View ha a disposizione un universo di servizi cloud, ed Android Studio offre a tutti i nostri progetti un ponte per creare app che dialoghino con essi.
All’inizio di ogni nuovo progetto, l’IDE propone diversi template che rappresentano i tipi più in voga di applicazioni e la configurazione è affidata ai file build di Gradle. Quest’ultimo è uno strumento di build automation che permette una configurazione molto flessibile con una sintassi mutuata dal linguaggio Groovy. Un contributo utilissimo che offre Gradle è la gestione delle dipendenze in stile Maven. Quando avremo bisogno di integrare librerie di sviluppo prodotte da Android o da
tramite cui si può inserire l’indirizzo da cui Eclipse provvederà per il download del plugin. L’URL richiesto è il seguente: http: //dl-ssl.google.com/android/ eclipse/. Dopo la connessione alla sorgente, nella finestra Available Software, apparirà il componenteDeveloper Tools: si dovrà spuntare la checkbox relativa ad esso e proseguire con l’installazione tramite pulsante Next. Successivamente, appena terminerà il download del componente, sarà necessario accettare la licenza d’uso proposta;
- Download dell’Android SDK: il plugin appena installato permetterà di avere a disposizione voci di menu relative allo sviluppo Android all’interno di Eclipse. L’ultimo passo consiste nel collegamento dell’IDE ad un Android SDK. Quest’ultimo, qualora non lo si possieda già nella propria macchina, può essere scaricato dal sito ufficiale di Android. Lo si dovrà scompattare sul nostro file system (ad esempio può essere posto all’interno della directory di Eclipse), e specificare il path della cartella nelle Preferences di Eclipse: selezionare la voce di menu Window -> Preferences e, nella sezione Android dell’interfaccia che appare, inserire il path del proprio SDK nella casella di testo SDK Location.
Android SDK
Come ultima nota, diamo uno sguardo più ravvicinato all’Android SDK. Un aspetto molto importante è che questo SDK è costituito da molti strumenti – programmi, emulatori, piattaforme per ogni versione di Android e molto altro – la cui composizione non è immutabile ma viene gestita tramite il programma Android SDK Manager , avviabile sia da Eclipse che da Android Studio. Grazie al Manager, il programmatore potrà profilare le piattaforme e gli strumenti presenti nel SDK nella maniera più congeniale al proprio lavoro. Maggiori dettagli in merito verranno via via presentati nel corso delle successive sezioni della guida.
Un paio di download, qualche click per installare e scompattare: indipendentemente dal sistema operativo del proprio PC, l’ambiente per lo sviluppo su Android non necessità di grandi operazioni per essere pronto all’utilizzo e alla realizzazione della prima app.
Come sviluppare app Android, ibrido o
nativo?
L’approccio alla programmazione Android appare del tutto agevole soprattutto grazie a due aspetti fondamentali già evidenziati: strumenti del tutto gratuiti e semplicità nell’apprestamento dell’ambiente di sviluppo. Ed in effetti è così. A volte però l’appassionato di tecnologia che si avvicina a questo mondo rischia di scoraggiarsi facilmente.
Ammesso che si possegga le skill necessarie del linguaggio Java, ci si accorge presto che un’infarinatura di sintassi spesso non è sufficiente. Per sfruttare degnamente le possibilità offerte dal framework è necessario essere dei buoni programmatori, consci delle principali problematiche da tenere sott’occhio in uno sviluppo professionale: ottimizzazione delle prestazioni, salvaguardia delle risorse a disposizione e via dicendo.
Ma allora che fare se non ci si sente attratti dalla programmazione di questo tipo, cosiddetta nativa , e non si vuole comunque rinunciare all’idea di vedere pubblicate le proprie app?
Alternative ce ne sono e consistono in strumenti – comunque validi – per lo sviluppo non nativo , dall’approccio più visuale e spesso familiare a chi proviene dal web design.
Eccone alcuni:
- Apache Cordova e Steroids scaturiscono dal know-how nello sviluppo per Internet. In effetti: se CSS ha reso il Web elegante, Javascript gli ha dato vitalità e HTML5 l’ha rivoluzionato, perché non riproporre questi strumenti nello sviluppo mobile? Cordova è la versione open source del progetto PhoneGap e serve a realizzare le cosiddette app ibride con un’interfaccia realizzata in modalità web ma in grado di interfacciarsi con il sistema operativo mobile mediante un vasto numero di API. Steroids nasce per superare alcuni limiti riscontrati in PhoneGap ma senza “reinventare la ruota”, si basa infatti su Cordova ma approfondisce il legame con lo strato nativo;
- Corona SDK è un ambiente particolarmente versato alla gestione dell’interazione come per i videogiochi. Creato dai Corona Labs non necessità di alcuna conoscenza del linguaggio Java e propone come alternativa lo scripting in LUA, un formalismo dall’approccio molto semplice che permette di personalizzare maggiormente le proprie applicazioni;
- Unity è il più diffuso motore per videogiochi del mondo. Il primato che gli spetta è pienamente meritato in quanto combina editor visuale di altissimo livello ma anche programmazione in tecnologie ad oggetti avanzate come C# oltre che gestione di altri aspetti fondamentali per i videogiochi come grafica, animazione e fisica;
- AppInventor è probabilmente la possibilità più abbordabile per l’appassionato di tecnologia a digiuno di programmazione e che desidera qualche risultato piuttosto rapido. E’ stato creato dai Google Labs come strumento per la rapida modellazione di app Android ed è stato successivamente ceduto al prestigioso M.I.T.. Intuitività e semplicità le sue chiavi di lettura principali.
Provider e BroadcastReceiver ed esistono affinchè la nostra applicazione possa integrarsi alla perfezione nell’ecosistema Android.
Prima di addentrarci nella spiegazione di ognuna di esse, è utile concentrarsi un attimo su due principi ispiratori che, tra gli altri, sono alla base della maggior parte delle scelte progettuali operate dai creatori di Android. Tenerli a mente ci permetterà di comprendere meglio ciò che del sistema verrà illustrato nei prossimi capitoli:
- (^) la salvaguardia delle risorse : essendo progettato per sistemi embedded, storicamente dotati di poche risorse di memoria, Android ha avuto sin da subito uno spirito parsimonioso. Vedremo che, senza far perdere fluidità alla user- experience, Android è particolarmente bravo nel distruggere e ricreare parti dell’applicazione in maniera del tutto impercettibile all’utente. Chi dovrà fronteggiare questo atteggiamento sarà il programmatore, ovviamente. Per fortuna, ciò non costerà grandi fatiche ma solo particolare cura nel prendere determinati accorgimenti da applicare con la necessaria consapevolezza. Vale la pena sottolineare che quando si parla di esiguità di risorse in Android, l’obiezione mossa più comunemente ruota attorno alla recente commercializzazione di smartphone che possono contare su 2 GB di memoria RAM. Ciò è vero ma non bisogna dimenticare che Android si propone lo scopo di animare qualunque dispositivo in cui riesca a vivere. Il sistema vincerà quindi la sfida di sopravvivenza solo se saprà adattarsi anche a contesti che offrono condizioni molto più disagiate di quelle che può prospettare un nuovissimo device Samsung;
- sicurezza : Android è figlio di Linux, come già ricordato, quindi ha nel DNA la ricerca della stabilità. Ogni applicazione è un utente a sé stante e vive in un proprio processo in cui viene allocata una nuova istanza della virtual machine, ciò per evitare che il crash di un’applicazione propaghi instabilità alle altre app in esecuzione. Questa forma di “isolamento” viene riflessa anche sulla memoria di massa in quanto ogni applicazione ha un suo spazio in cui lavorare e custodire i propri dati. In merito, è assolutamente sconsigliata, per non dire vietata, qualsiasi pratica che porti un’app ad invadere lo spazio riservato ad un’altra. Nonostante ciò le nostre applicazioni non sono costrette a vivere in assenza di comunicazione tra loro, anzi Android favorisce un dialogo “sano” tra di esse mettendo a disposizione meccanismi agevoli per la condivisione di contenuti e funzionalità tra componenti del sistema.
È arrivato il momento quindi di presentare più da vicino i blocchi costitutivi di un’applicazione.
Le fondamenta di Android
Un’ Activity è un’interfaccia utente. Ogni volta che si usa un’app generalmente si interagisce con una o più “pagine” mediante le quali si consultano dati o si immettono input. Ovviamente la realizzazione di Activity è il punto di partenza di ogni corso di programmazione Android visto che è il componente con cui l’utente ha il contatto più diretto.
Un Service svolge un ruolo, se vogliamo, opposto all’Activity. Infatti rappresenta un lavoro – generalemente lungo e continuato – che viene svolto interamente in background senza bisogno di interazione diretta con l’utente. I Service hanno un’importanza basilare nella programmazione proprio perchè spesso preparano i dati che le activity devono mostrare all’utente permettendo una reattività maggiore nel momento della visualizzazione.
Un Content Provider nasce con lo scopo della condivisione di dati tra applicazioni. La sua finalità richiama quel principio di sicurezza dell’applicazione di cui si è trattato poco fa. Questi componenti permettono di condividere, nell’ambito del sistema, contenuti custoditi in un database, su file o reperibili mediante accessi in Rete. Tali contenuti potranno essere usati da altre applicazioni senza invadere lo spazio di memoria ma stabilendo quel dialogo “sano” cui si è accennato
Un Broadcast Receiver è un componente che reagisce ad un invio di messaggi a livello di sistema – appunto in broadcast – con cui Android notifica l’avvenimento di un determinato evento, ad esempio l’arrivo di un SMS o di una chiamata o sollecita l’esecuzione di azioni. Questi componenti come si può immaginare sono particolarmente utili per la gestione istantanea di determinate circostanze speciali.
Molto importante ricordare che una componente può attivarne un’altra mediante apposite invocazioni di sistema. Questa intenzione viene codificata con un Intent utilizzabile come normale classe Java ma che sottintende un potentissimo strumento di comunicazione di Android. Anche degli Intent faremo uso sin dai prossimi articoli.
Il ciclo di vita di un’app Android
Android sa che il fattore fondamentale della sopravvivenza di un sistema mobile è la corretta gestione delle risorse. Pensiamo ad uno smartphone: è un dispositivo che fa una vita difficile al giorno d’oggi. Non solo si occupa di chiamate ed SMS, ma offre pagine web, giochi, comunicazione sui “social” per molto tempo ogni giorno. Inoltre, capita sempre più spesso che non venga mai spento impedendo così una
proprie applicazioni e di come esse vengano gestite dal sistema in ogni circostanza, più o meno favorevole.
La prima app Android con Eclipse
A questo punto, la filosofia del sistema è stata introdotta, gli strumenti necessari illustrati non resta altro da fare che partire con il primo progetto.
Lo scopo di questa lezione non è tanto quello di scrivere un vero e proprio programma quanto quello di farci accompagnare dall’IDE nella creazione di un progetto Android per poterne vedere la struttura, innanzitutto, e mandarlo in esecuzione in modo da verificare la corretta preparazione della nostra macchina di sviluppo.
Prendiamo contatto con l’IDE: creazione di un progetto
Probabilmente il programmatore novizio di Android sarà già più che svezzato nel mondo Java quindi non dovrebbe avere problemi ad orientarsi in Eclipse. Comunque, riepilogando, per poter testare la propria macchina di sviluppo è necessario innanzitutto creare un nuovo progetto Android:
- assicuriamoci di avere aperto la Perspective di Eclipse relativa a Java (e non a Java EE né a nessun altro tipo di framework). Per farlo, andiamo sul menu Window → Open Perspective. Se viene visualizzata la voce Java, selezioniamola; altrimenti possiamo procedere con il punto seguente;
- muovendoci nel menu File invochiamo New → Android Application Project;
- seguiamo la procedura di creazione guidata. La serie di schermate (circa 4 o 5) che si susseguono ci chiede di inserire una serie di impostazioni. L’unica assolutamente obbligatoria è il nome dell’applicazione. Diciamo che il nome scelto per questa prima applicazione sia – nemmeno a dirlo – HelloWorld, tutte le restanti impostazioni al momento possono essere lasciate con i valori di default , saranno comunque modificabili successivamente. Si può concludere la creazione del progetto selezionando sempre il pulsante Next finché non diventerà attivo quello denominato Finish.
L’ architettura di progetto così impostata è costituita da un certo numero di file e cartelle.
Tutti sono importanti ma gli elementi tra i quali il programmatore dovrà sapersi muovere al più presto con scioltezza sono:
- la cartella src che conterrà tutto il codice Java che scriveremo;
- la cartella res in cui risiederanno le cosiddette risorse dell’applicazione per la maggior parte configurate in XML ma non solo;
- il file AndroidManifest.xml anch’esso in XML che custodirà configurazioni e ruoli dei componenti della nostra app.
Un progetto creato in questa maniera da Eclipse è funzionante, sebbene non contenga nessuna funzionalità particolare. Al momento, quindi, non modifichiamo nulla e passiamo subito al suo avvio immediato.
Esecuzione del progetto: dispositivo emulato o reale?
Per eseguire il test è necessario che si abbia a disposizione un dispositivo Android attivo. Può trattarsi di un dispositivo reale – tipicamente smartphone o tablet collegato via USB – o di un sistema emulato (tecnicamente un AVD, Android Virtual Device) mediante gli strumenti messi a disposizione da Android SDK.
Esecuzione su un dispositivo emulato
Partiamo da questo secondo caso. Nel menu Window (attenzione, per vederlo è necessario trovarsi nella prospettiva Java e non Debug) sono disponibili due voci importantissime: “ Android SDK Manager ” e “ Android Virtual Device Manager ”. Il
- tornando alla finestra presentata al precedente punto 2. dovremmo vedere il nostro emulatore elencato nell’area bianca. Non resta che selezionarlo e avviarlo cliccando il pulsanteStart…
Esecuzione su un dispositivo fisico reale
Se si vuole utilizzare un dispositivo reale via USB non è richiesto apportare modifiche in Eclipse. Usando Windows sono solitamente necessari dei driver reperiti direttamente dal sistema operativo o scaricati appositamente dal programmatore. Qualora, al contrario, si usasse Linux non è richiesta l’installazione di alcun driver, macchina di sviluppo e Android si interfacceranno direttamente.
Lancio dell’applicazione
Dopo il boot del sistema emulato, potremo lanciare la nostra applicazione che verrà eseguita direttamente sul dispositivo. Ciò può essere fatto in modalità Run o Debug utilizzando uno dei mezzi messi a disposizione dall’IDE (voci nel menu Run, combinazione di tasti o pulsanti sulla barra degli strumenti).
Il risultato dell’esecuzione – visibile in figura – è molto semplice.
Consiste nella sola apparizione della stringa “Hello world!”. Non è molto ma certifica il raggiungimento dei nostri obiettivi : la macchina di sviluppo è pronta per mettersi al lavoro e, seconda cosa, l’impianto di progetto che abbiamo ora a disposizione è funzionante e può essere usato come base per sperimentare tutto ciò che impareremo.
Anche su Android Studio troveremo tre parti principali del progetto: la cartella con il codice Java, la cartella res (contenente risorse per lo più realizzate in XML) ed un file di configurazione denominato AndroidManifest.xml. La figura seguente mostra la disposizione di tali elementi.
Per prima cosa, si noti che il progetto è contenuto in una cartella denominata app. Questo è il modulo di default. L’IDE, infatti, suddivide un progetto in più moduli, ognuno dei quali può svolgere un ruolo diverso (libreria Java, libreria Android, inclusione di un progetto esterno, eccetera…). Il modulo app include i file manifest, il codice Java e le risorse.
Dopo il modulo troviamo la sezione Gradle Scripts. Qui ci sono i file di build che userà Gradle per trasformare il nostro progetto in un’app funzionante. In particolare, i file di build sono due: uno per tutto il progetto ed uno per il solo modulo app. Vediamo di seguento quest’ultimo, che è quello tipicamente modificato dal programmatore.
apply plugin: 'com.android.application'
android {
compileSdkVersion 21
buildToolsVersion "22.0.1"
defaultConfig {
applicationId "it.html.helloworld"
minSdkVersion 14
targetSdkVersion 21
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:22.1.1'
}
La prima riga carica il plugin Gradle per android. Questo permette di avere a disposizione la sezione seguente contenuta nella direttiva android { ... }. Al suo interno vengono impostati alcuni fattori che nei progetti Eclipse trovano spazio nel file AndroidManifest.xml: minimo SDK cui l’app è destinata ( minSdkVersion), SDK target (targetSdkVersion ), versione di sviluppo ( versionCode ) e versione pubblica (versionName ).
La sezione successiva denominata dependencies, è molto importante per l’espansione delle funzionalità del progetto.
La riga seguente:
compile fileTree(dir: 'libs', include: ['*.jar'])
include nel build path tutti i file .jar che trova nella cartella libs, mentre la riga:
compile 'com.android.support:appcompat-v7:22.1.1'
Activity, la “prima pagina”
dell’applicazione
Il progetto approntato nel capitolo precedente con l’aiuto dell’IDE può essere ora analizzato nel dettaglio. Lo scopo che ci prefiggiamo è quello di osservare da vicino come è fatta un’Activity, il primo dei quattro componenti basilari che troviamo nelle applicazioni Android.
Nel nostro progetto ce n’è una ed è l’interfaccia utente che mostra il messaggio “Hello World”. Nonostante la sua semplicità, mette in luce un aspetto fondamentale. Per creare un’Activity è necessario fare due cose:
- estendere la classe Activity , appartenente al framework Android;
- (^) registrare l’Activity nell’AndroidManifest.xml mediante l’uso dell’apposito tag XML . Tra l’altro, questo dettame vale per tutte le quattro componenti fondamentali di un’applicazione.
L’Activity nel codice Java
Il codice Java che realizza l’Activity risiede nella cartella src , come spiegato in precedenza. Il contenuto di un tipico “Hello world” potrebbe essere questo:
public class MainActivity extends Activity
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
La classe si chiama MainActivity ed estende Activity. Al suo interno viene implementato l’override del metodo onCreate. Per il momento, ci accontentiamo di sapere che questo metodo viene invocato alla creazione dell’Activity. Più avanti scopriremo che si tratta di una tappa fondamentale del ciclo di vita di questo tipo di componenti.
A proposito delle due righe di codice presenti all’interno dell’onCreate:
