Scarica Appunti programmazione Android e più Appunti in PDF di Programmazione Avanzata solo su Docsity!
CICLO DI VITA DI UN’APPLICAZIONE
Un’attività viene lanciata, poi si invoca il metodo onCreate() non appena si attiva l’applicazione. Poi viene lanciato onStart(), poi onResume() quindi l’attività è in esecuzione. Quando succede qualcosa, l’attività và in foreground e quindi in pausa con onPause(). Quando l’attività non è più visibile allora va stoppata e poi può essere chiusa o dall’utente o dal sistema. Da onPause() può essere riabilitata e può tornare ad onStart() Per fare in modo che i nostri dati della app non vengano persi dobbiamo fare in modo che in uno degli stati che vengono eseguiti, onPause(), onStop() oppure onDestroy(), salvino il contenuto per poterlo riutilizzare in seguito. Facciamo ciò mediante sharedPreferences.
ANDROID MANIFEST
E’ un manifesto XML dell’applicazione che serve a specificare cosa può fare un’app e specifica i vari campi che la caratterizzano. Ecco i campi più importanti: Il tag è stato già incontrato parecchio nel corso di questa guida. Necessario ogni volta che la nostra applicazione deve avviare comunicazioni o accessi particolari, richiede almeno che la definizione dell’attributo android:name, che specifica esattamente il tipo di permission richiesta. Finora l’abbiamo incontrato in: accesso alla Rete: android.permission.INTERNET; localizzazione: android.permission.ACCESS_FINE_LOCATION e android.permission.ACCESS_COARSE _LOCATION; storage esterno: android.permission.WRITE_EXTERNAL_STORAGE; comunicazioni telefoniche: android.permission.CALL_PHONE e android.permission.READ_PHONE_STATE; Content Providers : vari casi (contatti, calendario, chiamate, etc…). Infine, <uses-feature> è la risposta alla frammentazione hardware e software del sistema Android. Permette di specificare di quali caratteristiche hardware o software l’applicazione ha bisogno per funzionare. Gli attributi di cui dispone sono: android:name: una stringa che definisce quale dotazione del dispositivo è necessaria affinchè l’applicazione funzioni correttamente. A livello hardware, si potrebbe avere bisogno di verificare se l’equipaggiamento elettronico del device comprende tecnologie come Bluetooth o NFC, nonchè dispositivi come la videocamera o lo schermo multitouch; android:required: è un valore booleano. Se impostato a true indica che la caratteristica è assolutamente obbligatoria per il funzionamento dell’app; altrimenti indica che la feature è fortemente consigliata ma non obbligatoria; android:glEsVersion: indica la versione delle librerie OpenGL ES richiesta dall’app. android:icon: si utilizza per assegnare un’immagine all’icona dell’app, tale immaggine va inserito nelle risorse (drawable); android:label: assegna il nome che verrà riportato come titolo; android:supportRTL: dichiare se l’app supporta il layout da destra a sinistra; android:theme=”@style/AppTheme”: modifica il tema dell’app; activityandroid:nome=”MainActivity”: è il riferimento dove è scritto il codice di cosa vogliamo far fare alla nostra app e può essere utilizzato in combinazione con altre categoria per altri scopi specifici; activity android:nome=”android.intent.category.LAUNCHER” fornisce ulteririori informazioni in merito all’azione da eseguire.
La gestione delle permission è cambiata radicalmente in Android 6 (ovvero dalla versione 23 delle API). A partire da questa versione, infattti, le permission dangerous dovranno essere accettate dall’utente al momento del primo utilizzo e tale permesso potrà essere revocato in qualsiasi momento, accedendo alle impostazioni dell’app. Per sviluppare app moderne, quindi, è necessario gestire le permission a runtime , verificando se esse siano revocate o meno, nonchè richiedendo all’utente di abilitarle. La classe ContextCompat , inclusa nella libreria di supporto, mette a disposizione un metodo per effettuare questo tipo di controllo: int statoPermission = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION); dove this rappresenta la nostra Activity (che fungerà da Context). Il valore della variabile intera statoPermission sarà confrontato con le costanti PackageManager.PERMISSION_GRANTED oppure PackageManager.PERMISSION_DENIED che equivalgono, rispettivamente, alla concessione del permesso o al suo diniego. Dovremo verificare la disponibilità di una permission prima di utilizzare il metodo che ne ha bisogno, e qualora essa non fosse disponibile dovremo chiedere all’utente di acconsentire lanciando un apposito Intent. Per far comparire una finestra di dialogo che richieda l’accettazione della permission. Abbbiamo così passato un array di stringhe contenente le permission che dovranno essere accettate, ed una costante intera che noi abbiamo chiamato ID_RICHIESTA_PERMISSION, che permetterà di identificare la specifica richiesta che abbiamo inoltrato. Il risultato sarà inviato inviato ad un metodo che noi predisporremo: Si realizza la struttura di controllo da usare per far sì che l’utente acconsenta a svolgere attività soggette ad una permission dangerous. L’utente sarà sempre padrone di revocare le permission dangerous concesse, semplicemente agendo sul controllo che apparirà tra le impostazioni dell’app.
LAYOUT DI APP ANDROID
Un’Activity ha bisogno di un volto, di un suo aspetto grafico. La struttura grafica di un’Activity prende il nome di Layout.
L’interfaccia grafica
Le interfacce utente in Android possono essere create in modo procedurale o dichiarativo. Android permette la creazione di interfacce sia procedurali sia dichiarative: possiamo creare un’interfaccia utente completamente in codice Java (metodo procedurale) oppure possiamo creare l’interfaccia utente attraverso un descrittore XML (metodo dichiarativo). Android inoltre permette anche un approccio ibrido, in cui si crea un’interfaccia in modo dichiarativo e la si controlla e specifica in modo procedurale (si richiama il descrittore XML da codice e si continua a lavorare da lì). Nella prassi, su Android un layout viene progettato in XML , in una modalità che ricorda molto l’uso di HTML per le pagine web. Gli IDE offrono strumenti visuali per disegnare layout con approccio drag-and-drop e visualizzazioni di anteprima molto utili.
Tipi di Layout
Nel framework Android sono stati definiti vari tipi di layout ma ce ne sono tre di utilizzo molto comune che permettono di affrontare ogni situazione:
- LinearLayout : contiene un insieme di elementi che distribuisce in maniera sequenziale dall’alto verso il basso (se definito con orientamento verticale) o da sinistra a destra (se ha orientamento orizzontale, il valore di default).
- TableLayout : altro layout piuttosto semplice, inquadra gli elementi in una tabella e quindi è particolarmente adatto a mostrare strutture regolari suddivise in righe e colonne.
- RelativeLayout : sicuramente il più flessibile e moderno. Adatto a disporre in maniera meno strutturata gli elementi. Essendo “relative” gli elementi si posizionano in relazione l’uno all’altro o rispetto al loro contenitore, permettendo un layout fluido che si adatta bene a display diversi.
Elementi comuni nei layout
Gli attributi XML utilizzati per la maggior parte proverranno da un namespace avente URI http://schemas.android.com/apk/res/android. Per questo motivo quando definiremo layout in un progetto Android il nodo root che conterrà tutti gli elementi mostrerà al suo interno la dichiarazione il name space e darà senso al prefisso android: che verrà usato per tutti gli attributi nel file. Secondo aspetto comune non solo ai layout ma anche a tutti gli elementi in essi contenuti, la presenza obbligatoria di due attributi: layout_width e layout_height , che definiscono la capacità dell’elemento di estendersi, rispettivamente, in larghezza (width) o altezza (height). Il loro valore può essere una dimensione, espressa in dp, come già spiegato, o una costante da scegliere tra: wrap_content : l’elemento sarà alto o largo a sufficienza per includere il suo contenuto; match_parent : l’elemento si estenderà in altezza o in larghezza fino a toccare il suo contenitore.
VIEW
Con questo termine intendiamo un qualunque elemento che appare in un’interfaccia utente e che svolge due funzionalità : mostra un aspetto grafico; gestisce eventi relativi all’interazione con l’utente. Una classe derivata da View è ViewGroup. Esso è, al contempo, un tipo di View e un contenitore di altre View. Tanto per fare un esempio di ViewGroup pensiamo ai layout, sono tipici raggruppatori di View.
Classificazione di View
Tutto ciò che tratteremo come un controllo utente in Android sarà direttamente o indirettametne discendente di una View. Le tipologie di View da presentare si articoleranno per lo più in tre categorie: i layout di cui si è discusso nei precedenti capitoli; i controlli utente che renderanno le nostre applicazioni interattive. Il loro utilizzo, spiegato a breve, si snoderà tra posizionamento nei layout e configurazione dei loro gestori di evento; gli AdapterView sono delle View, generalmente nello stesso package dei controlli utente, che collaborano nella realizzazione del pattern Adapter.
View e id
Prima di tutto gli id. Nei file di risorse, gli attributi id hanno un valore definito come @+id/ identificatore dove per identificatore si intende il nome dell’id scelto dall’utente. Il simbolo + apposto dopo la @ indica che se l’id con quel nome non è stato ancora definito nel sistema sarà definito per l’occasione.
Gestione degli eventi
La gestione degli eventi viene realizzata con il meccanismo dei listener. I tre punti cardine sono:
- il recupero di un riferimento alla View della quale verranno monitorati gli eventi;
- la definizione di un oggetto (anonimo in questo caso) che contiene un metodo onClick definito appositamente per gestire l’evento di click;
- la registrazione del listener tramite un metodo setter affinché il pulsante sappia chi è l’oggetto a cui delegare la gestione dei click.
CONTROLLI UTENTE
Discendono dalla classe View , ma quali sono tra essi i più comuni? TextView : la classica label. Serve a rappresentare del testo fisso; EditText : corrisponde all’inputbox di altre tecnologie. Viene usata per permettere l’inserimento del testo. Mediante attributi XML può essere adattata alle proprie necessità. Molto utile è android:inputType i cui valori definiscono i formati più comuni di input (date, password, testo, etc.); Button : è il pulsante. La casistica più comune comporterà la gestione dell’evento click per attivare una qualche reazione nell’Activity; CheckBox : come ci si aspetta definisce un classico flag che può essere attivato o disattivato. Nel codice Java leggeremo il suo stato (checked o unchecked) mediante un valore booleano; Radio : esistono i radiobutton come in ogni altra tecnologia per interfacce utente. Vengono solitamente usati per definire valori alternativi tra loro come il sesso di una persona (maschio/femmina), possesso di facoltà (automunito Sì/No), etc. Questi non sono che alcuni esempi: come si può immaginare, un elenco esaustivo avrebbe dimensioni imponenti. Tuttavia, si può fare riferimento alla documentazione ufficiale per ulteriori approfondimenti.
CREARE MENU
Le tipologie di menu più comuni in Android sono due: Options menu : è il menu principale dell’applicazione e contiene voci riguardanti operazioni di interesse generale nella vita dell’app. Context Menu : è un menu invocabile su un singolo componente dell’interfaccia utente. Le voci richiamabili serviranno ad avviare operazioni sull’elemento su cui è stato richiesto il menu. Normalmente un menu contestuale viene attivato con un click lungo su un componente del layout.
Definire la struttura del menu
Il primo passo per aggiungere un menu di qualsiasi tipo alla nostra Activity è crearne la struttura. In proposito, va sempre tenuto a mente che i menu sono risorse. Quindi il loro layout va definito nella sottocartella res/menu. Questo è il punto di partenza della creazione di un menu. Per poter creare un menu minimale, sono sufficienti due tag:
