Last Updated on 2 anni | Published: 30/03/2024
Android è il sistema operativo mobile più diffuso al mondo, sviluppato da Google. Una delle principali ragioni del suo successo è la sua flessibilità e la vasta gamma di dispositivi su cui può essere eseguito. Per sviluppare applicazioni per Android, è essenziale conoscere il linguaggio di programmazione predominante, che è Java (e Kotlin come alternativa moderna).
Java: Linguaggio Storico di Android
Java è stato il linguaggio principale per lo sviluppo di applicazioni Android sin dalla sua nascita. È un linguaggio di programmazione orientato agli oggetti, il che significa che è focalizzato sulla creazione di classi e oggetti che interagiscono tra loro per eseguire operazioni specifiche.
Nel contesto di Android, Java viene utilizzato per sviluppare le logiche di backend delle applicazioni. Ad esempio, gestire l’accesso ai dati, la logica di business e l’interazione con il sistema operativo.
Struttura Base di un' app Android
Un’ app Android è composta da diversi componenti che collaborano tra loro per fornire un’esperienza utente completa. Le principali componenti di un’app Android includono:
- Activity: Rappresenta una singola schermata con cui l’utente può interagire. Ogni Activity è associata a un file XML che definisce la UI (User Interface).
- Service: È un componente che esegue operazioni in background senza fornire un’interfaccia utente.
- Broadcast Receiver: Gestisce i messaggi provenienti dal sistema o da altre applicazioni.
- Content Provider: Gestisce l’accesso ai dati dell’app, consentendo la condivisione di dati con altre applicazioni.
Ciclo di vita di un' app Android
Il ciclo di vita di un’app Android si riferisce alla serie di stati attraversati da un’applicazione Android dall’avvio alla terminazione. Questi stati determinano come l’app interagisce con l’utente e come gestisce le risorse di sistema.
Il ciclo di vita è fondamentale per comprendere quando e come eseguire operazioni specifiche, come la creazione di risorse, l’inizializzazione di componenti e la gestione della memoria.
Ecco una panoramica del ciclo di vita di un’app Android:
- Stato di Creazione (Created)
- L’applicazione viene creata ma non è ancora visibile all’utente.
- Il metodo
onCreate()dell’Activity viene chiamato in questo stato.
- Stato di Avvio (Started)
- L’applicazione è visibile all’utente, ma non è ancora interattiva.
- Il metodo
onStart()dell’Activity viene chiamato in questo stato.
- Stato di Pausa (Paused)
- L’applicazione è ancora visibile all’utente, ma un’altra applicazione o una finestra ha il focus.
- Il metodo
onPause()dell’Activity viene chiamato quando l’applicazione entra in questo stato.
- Stato di Stoppato (Stopped)
- L’applicazione non è più visibile all’utente e non è più attiva.
- Il metodo
onStop()dell’Activity viene chiamato in questo stato.
- Stato di Riavvio (Restarted)
- L’applicazione sta per tornare allo stato di avvio dopo essere stata in stato di pausa o stop.
- Il metodo
onRestart()dell’Activity viene chiamato quando l’applicazione entra in questo stato.
- Stato di Distrutto (Destroyed)
- L’applicazione è stata terminata o il sistema operativo ha deciso di distruggerla per liberare risorse.
- Il metodo
onDestroy()dell’Activity viene chiamato in questo stato.
Android Studio
Sviluppare un’applicazione Android con Java richiede una serie di passaggi e l’uso di strumenti specifici.
Prerequisiti
- Installare Android Studio: È l’IDE ufficiale per lo sviluppo di app Android e include tutto ciò di cui hai bisogno per iniziare.
- Avere una conoscenza di base del linguaggio di programmazione Java.
Iniziamo con MainActivity
Creare una semplicissima app Android con Android Studio utilizzando Java è un ottimo punto di partenza per chi è alle prime armi. Di seguito un esempio di come creare un’app Android con una sola classe Java che contiene il metodo per restituire un saluto di benvenuto.
In Android, quando si parla di R., si fa riferimento alla classe R generata automaticamente dal sistema di build di Android (generalmente attraverso il tool aapt, che sta per Android Asset Packaging Tool). Questa classe è responsabile di generare costanti statiche per tutte le risorse (come layout, stringhe, immagini, stili, ecc.) che sono presenti nel progetto Android.
Nell’ esempio sopra riportato R.layout per fare riferimento al layout activity_main.
Ricordiamo che il file AndroidManifest.xml contiene la definizione per stabilire quale Activity sarà la principale e quindi avviata per prima, indipendentemente se il nome è MainActivity oppure altro.
Struttura di Base
Quando si apre un progetto, si ha la possibilità di visualizzarlo in due modalità principali: “Android” e “Project“. Ognuna di queste modalità offre una prospettiva diversa sul progetto.
Prospettiva Android: la struttura del progetto viene presentata in una forma più astratta e organizzata, focalizzata sui componenti specifici dell’applicazione Android, come le activity, i fragment, le risorse e il file di manifesto.
Prospettiva Project: ti mostra il progetto come una struttura di directory standard del progetto, che include tutte le directory e i file presenti nella cartella del progetto.
Struttura di Base
app/: È la directory del modulo dell’app, dove si trova il codice sorgente, le risorse e le configurazioni specifiche per l’app.java/: Contiene i file sorgente Java (o Kotlin) dell’app.MainActivity.java: È la classe principale dell’app, che estendeAppCompatActivitye rappresenta l’activity principale dell’app.res/: È la directory che contiene tutte le risorse dell’app.drawable/: Contiene le immagini e altri file grafici utilizzati nell’app.layout/: Contiene i file XML che definiscono l’interfaccia utente dell’app.mipmap/: Contiene le icone dell’app in diverse dimensioni.values/: Contiene i file XML che definiscono vari valori come stringhe, colori, stili e dimensioni.strings.xml: È il file XML che contiene tutte le stringhe di testo utilizzate nell’app.AndroidManifest.xml: È il file di manifesto dell’app, che contiene informazioni sulle componenti dell’app, come le activity, i servizi, i permessi e altri metadati.build.gradle: È il file di configurazione del build per il modulo app, dove vengono definiti le dipendenze, i plugin e altre configurazioni specifiche per il build dell’app.settings.gradle: È il file di configurazione principale del progetto, che definisce i moduli del progetto.
Le Activity in Android
In Android, un Activity rappresenta una singola schermata con un’interfaccia utente. Può contenere elementi come bottoni, campi di testo, immagini e altri componenti UI. Un’app può avere una o più Activity, e queste possono interagire tra loro attraverso intenti.
Possiamo creare il progetto, ActivityMultiple, contenente la classe MainActivity (o altro nome se preferite):
A questo punto possiamo iniziare a programmare il Layout di MainActivity attraverso il file activity_main.xml posizionato nel package ‘layout‘, aggiungendo i due pulsanti per aprire le rispettive activity.
Classe Intent
Comunicazione e Navigazione
Nel mondo Android, un componente fondamentale per la navigazione tra le diverse schermate dell’app è rappresentato dall’uso delle Intent. Le Intent sono oggetti che forniscono un meccanismo per comunicare tra componenti differenti dell’app, come ad esempio tra diverse Activity.
Infatti nell’ esempio sopra, la la classe MainActivity utilizza proprio la classe Intent per avviare la successiva activity.
E’ possibile passare dati tra Activity in Android utilizzando l’oggetto Intent. Questo è un meccanismo molto comune per trasferire informazioni, come stringhe, numeri, oggetti serializzati e così via, da un’Activity all’altra.
Progetto di Esempio: ClasseIntent
Nel prossimo esempio utilizziamo un widget ListView aggiungendo ad esso elementi utilizzando un ArrayAdapter, quindi vediamo l’ implementazione dell’ activity Clienti, che contiene anche il widget ListView
ArrayAdapter è una classe fornita dal framework Android che funge da bridge tra un ListView e un set di dati sottostante. Utilizza un ArrayList o un array di oggetti come set di dati e converte ciascun oggetto in un singolo elemento visualizzato all’interno del ListView.
context: il contesto corrente (generalmente l’Activity).
resource: l’ID del layout che definisce come apparirà ciascun elemento nel ListView.
objects: la lista di oggetti da visualizzare nel ListView.
L’istruzione assert in Java è un meccanismo utilizzato per eseguire controlli di asserzione nel codice.
Un’asserzione è una dichiarazione che il programmatore crede debba essere sempre vera in un determinato punto del codice. L’obiettivo principale delle asserzioni è di catturare errori di programmazione, ovvero situazioni in cui qualcosa va storto durante l’esecuzione del programma che non dovrebbe mai accadere in condizioni normali.
Progetto di Esempio: ClasseIntentBis
Classe Intent - Oggetti Serializzati
Nello sviluppo di applicazioni Android, una delle sfide più comuni è il passaggio di dati complessi tra le varie activity. Una soluzione efficace a questo problema è l’utilizzo di oggetti serializzati. In questo esempio, esploreremo cosa significa serializzare un oggetto e come utilizzarlo per scambiare dati tra le activity in Android.
La serializzazione è il processo di conversione di un oggetto in una sequenza di byte, che può essere facilmente salvata in un file o trasmessa su una rete. La deserializzazione è il processo inverso, che converte una sequenza di byte in un oggetto.
Nell’ esempio sopra la Classe Studenti è implementata come Serializable.
Una volta che hai un oggetto serializzabile, puoi passarlo tra le activity utilizzando putExtra(), nel MainActivity, e getSerializableExtra(), nella StudentActivity.
Progetto di Esempio: OggettoStudente
Approfondimenti Classe Intent
Un Intent è un oggetto che fornisce un mezzo per descrivere una richiesta di azione o un evento che deve essere eseguito.
Come abbiamo visto negli esempi precedenti può essere utilizzato per avviare un componente specifico, Intent Esplicito:
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent);
Oppure per il passaggio di parametri primitivi utilizzando putExtra(), come abbiamo anche visto come passare oggetti complessi tra Activity con l’ implementazione della Classe Serializable
La classe Intent in Android non è limitata solo al passaggio di dati e alla navigazione tra le activity. È uno strumento molto versatile che può essere utilizzato per una varietà di scopi, inclusi l’interazione con componenti hardware come la fotocamera o la webcam, la gestione di servizi e la comunicazione con altre applicazioni.
Interazione con Componenti Hardware
Comunicazione con altre App
Intent.ACTION_SEND
Invia dati come testo o file a un’altra app.
Intent.ACTION_SENDTO
Invia dati come testo a un’altra app specificando una URI.
Intent.ACTION_VIEW
Visualizza dati come un URL, una posizione geografica o un file.
Altri Utilizzi Avanzati
Intent.ACTION_WEB_SEARCH
Avvia una ricerca web con i dati specificati.
Intent.ACTION_DIAL
Avvia l’applicazione del telefono per comporre un numero.
Intent.ACTION_VIEW
con URI tel: Visualizza un numero di telefono.
Intent.ACTION_VIEW
con URI geo: Visualizza una posizione geografica su una mappa.
Di seguito riportiamo un semplice esempio che utilizza MediaStore.ACTION_IMAGE_CAPTURE per scattare una foto e visualizzarla su un ImageView nella stessa Activity.
Progetto di Esempio: OggettoStudente
Nella MainActivity alla riga-13 abbiamo la costante private static final REQUEST_IMAGE_CAPTURE ed è utilizzata come codice identificativo per la richiesta di cattura immagine. Il valore della costante è un intero e non ci sono restrizioni particolari sul valore che può avere, ma è buona pratica utilizzare un valore unico e facilmente riconoscibile.
Questo valore può essere utilizzato per distinguere la richiesta di cattura dell’immagine da altre possibili richieste che potresti avere all’interno della stessa attività. Puoi scegliere qualsiasi altro valore intero, purché sia univoco all’interno della tua attività.
L’ oggetto takePictureIntent (riga-22) crea quindi un nuovo Intent per avviare l’ applicazione della fotocamera, consentendo quindi all’ utente di scattare foto.
Alla riga-23 utilizziamo il metodo della classe Activity, startActivityForResult che permette di avviare un’altra attività (come l’applicazione della fotocamera, nel nostro caso) e di attendere un risultato ritornato da quella attività.
Nel contesto del codice, quando l’attività della fotocamera viene completata e l’utente scatta una foto, l’attività principale riceverà il risultato attraverso il metodo
La riga-30 del metodo ereditato onActivityResult verifica se il codice della richiesta corrisponde a quello dell’ Intent per la cattura dell’ immagine e se il risultato dell’ operazione è stato positivo (l’ utente ha catturato e salvato un’ immagine).
La costante RESULT_OK è definita nella classe Activity di Android. Fa parte del framework Android e viene utilizzata per indicare che un’operazione è stata completata con successo. Il valore effettivo di RESULT_OK è -1.
La riga-31 ottiene l’ extra “data” dall’ Intent, che contiene l’ immagine catturata come Bitmap, mentre la riga-33, estrae l’ immagine Bitmap dall’ extra “data“. Infine la riga-34 imposta l’ immagine Bitmap sull’ ImageView per essere visualizzata.
Inoltre nel file AndroidManifest.xml dobbiamo aggiunegere i permessi:
<uses-permission android:name=”android.permission.READ_EXTERNAL_STORAGE” android:maxSdkVersion=”32″ />
La Classe Uri - Panoramica ed Utilizzo
Nel mondo dello sviluppo Android, la gestione delle risorse e dei dati è fondamentale. La classe Uri (Uniform Resource Identifier) gioca un ruolo cruciale nella rappresentazione e nel riferimento a risorse, sia locali che remote, all’interno di un’applicazione Android. Questo articolo fornirà una panoramica completa della classe Uri e illustrerà come utilizzarla in applicazioni Android.
Un Uri è una sequenza di caratteri che identifica un nome o una risorsa su un sistema. In Android, una Uri è comunemente utilizzata per identificare e accedere a risorse come file, contenuti di database, immagini, video e altro ancora.
Una Uri è generalmente composta da diversi componenti:
- Schema: Definisce il protocollo utilizzato (es.
http,https,file,content). - Authority: Indica l’entità che controlla l’accesso alla risorsa (es. nome del dominio, nome del file, nome del provider).
- Percorso: Specifica la posizione della risorsa all’interno dell’autorità.
- Query: Parametri aggiuntivi per la risorsa.
- Fragment: Parte specifica della risorsa, solitamente utilizzata per identificare una sotto-parte.
Ecco alcuni degli schemi di URI più comuni:
- http e https:
- Schemi utilizzati per identificare risorse web, come pagine HTML, immagini, documenti, ecc.
- Ex:
http://www.example.com
- ftp:
- Schemi utilizzato per accedere e trasferire file attraverso il protocollo FTP (File Transfer Protocol).
- Ex:
ftp://ftp.example.com
- mailto:
- Schema utilizzato per creare un link che apre il client di posta elettronica con un destinatario preimpostato.
- Ex:
mailto:info@example.com
- tel:
- Schema utilizzato per identificare numeri di telefono.
- Ex:
tel:+123456789
- geo:
- Schema utilizzato per identificare posizioni geografiche.
- Ex:
geo:45.4642,9.1900
- file:
- Schema utilizzato per identificare file locali o file accessibili via file system.
- Ex:
file:///path/to/file.txt
- data:
- Schema utilizzato per incorporare dati direttamente nell’URI.
- Ex:
data:text/plain;charset=utf-8,Hello%20World!
- content:
- Schema utilizzato per identificare contenuti forniti da un Content Provider su Android.
- Ex:
content://com.example .provider/data/1
- market:
- Schema utilizzato per collegarsi al Google Play Store.
- Ex:
market://details?id=com.example.app
- intent:
- Schema utilizzato per comunicare tra componenti di un’applicazione Android.
- Ex:
intent://scan/#Intent; scheme=zxing;package=com.google.zxing.client.android;end
Comunicazione con altre App
Vediamo con il prossimo esempio cosa si intende per comunicazione con le altre app, infatti molto semplicemente utilizziamo Intent.ACTION_VIEW per visualizzare un numero di telefono sull’ app del cellulare oppure inviare un SMS :
Progetto di Esempio: ChiamaNumero
Il prossimo esempio utilizza sempre l’ azione ACTION_VIEW, in combinazione con Uri che rappresenta una posizione geografica, per aprire una mappa e visualizzare quella specifica posizione:
La riga-19 contiene l’ Uri geo: latitudine+longitudine che viene utilizzato per specificare una posizione geografica (latitudine e longitudine). Inoltre la riga-29 viene utilizzata per specificare esplicitamente l’applicazione di mappe da utilizzare, che in questo caso è Google Maps. Se si omette questa linea, il sistema Android cercherà automaticamente un’applicazione di mappe appropriata per gestire l’Intent basandosi sull’URI fornito. Questo può essere utile se desideri che l’utente scelga tra diverse applicazioni di mappe installate sul dispositivo.
Progetto di Esempio: AppMaps
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
La Classe Bundle
il Bundle (mappa chiava-valore) è una classe fondamentale in Android utilizzata per passare dati tra componenti diversi, come Activity, Service e Fragment. Un Bundle può essere utilizzato per trasferire dati primitivi, oggetti serializzabili e altre strutture di dati tra le diverse parti di un’applicazione Android.
Molto semplicemente per creare un Bundle si può istanziare un nuovo oggetto Bundle ed aggiungere dati ad esso con i metodi come putString(), putInt().
Una volta creato il Bundle ad esempio può essere passato ad un Fragment utilizzando il metodo setArguments(), mentre all’ interno del Fragment il Bundle si può recuperare attraverso getArguments() dell’ oggetto Bundle.
Il prossimo paragrafo è un ottimo esempio per apprendere come utilizzare il Bundle con un Fragment.
Fragment in Android
I Fragment sono una parte fondamentale dello sviluppo delle applicazioni Android, offrendo una flessibilità e una modularità che va oltre le semplici Activity. In questo articolo, esploreremo in dettaglio cosa sono i Fragment, come funzionano e come utilizzarli efficacemente nelle tue applicazioni Android.
In altre parole, un Fragment è un “pezzo riutilizzabile” di interfaccia utente o di funzionalità che può essere integrato all’interno di diverse Activity o combinato per creare un’interfaccia utente complessa.
Un Fragment ha i suoi vantaggi e vediamo quali sono:
Modularità
I Fragment permettono di suddividere l’interfaccia utente in componenti modulari, rendendo più facile la gestione e la manutenzione del codice.
Riutilizzabilità
Essendo componenti indipendenti, i Fragment possono essere riutilizzati in diverse parti dell’applicazione o in diverse applicazioni.
Flessibilità
I Fragment possono essere aggiunti, rimossi o sostituiti dinamicamente durante l’esecuzione dell’applicazione, offrendo una maggiore flessibilità nella gestione dell’interfaccia utente.
Supporto Multi-pane
I Fragment sono particolarmente utili per le applicazioni tablet o per le interfacce utente multi-pane, consentendo di mostrare più contenuti in modo simultaneo sullo schermo.
Un Fragment ha un ciclo di vita simile a quello di un Activity, composto dalle seguenti fasi:
- onAttach(): Il Fragment viene allegato all’Activity.
- onCreate(): Viene creato il Fragment.
- onCreateView(): Viene creato la vista del Fragment.
- onActivityCreated(): Viene notificato che l’Activity è stata creata.
- onStart(): Il Fragment diventa visibile.
- onResume(): Il Fragment diventa attivo.
- onPause(): Il Fragment perde il focus ma rimane visibile.
- onStop(): Il Fragment non è più visibile.
- onDestroyView(): Viene distrutta la vista del Fragment.
- onDestroy(): Viene distrutto il Fragment.
- onDetach(): Il Fragment viene rimosso dall’Activity.
Vediamo un esempio di Fragment Statico che implementa il metodo onCreateView()
Nell’ esempio sopra riportato il Fragment (classe Fragment) implementa il metodo onCreateView() che è uno dei metodi fondamentali del ciclo di vita di un Fragment.
Questo metodo viene chiamato quando il Fragment deve creare la sua interfaccia utente e quindi bisogna inflazionare (creare) una vista che rappresenta il layout del Fragment e restituirla, quindi
inflater.inflate()
Il metodo inflater.inflate() viene utilizzato per convertire un file XML di layout in una gerarchia di oggetti View in memoria. Questo è fondamentale perché ti permette di “tradurre” il tuo layout XML in una struttura di oggetti che Android può comprendere e visualizzare sullo schermo.
Layout Resource ID (R.layout.fragment_condiviso): Questo è l’ID del file XML di layout che desideri inflazionare. Ad esempio, R.layout.fragment_condiviso si riferisce a fragment_condiviso.xml nel tuo progetto.
Container (container): Questo è il contenitore in cui il Fragment verrà visualizzato. È un oggetto ViewGroup in cui il Fragment sarà inserito. Solitamente, si tratta di un FrameLayout o un altro tipo di layout che può contenere un Fragment.
Attach to Root (false): Questo parametro indica se la vista inflazionata dovrebbe essere immediatamente attaccata al contenitore specificato.
Se impostato su true, la vista inflazionata verrà automaticamente aggiunta al container. Se impostato su false, dovrai aggiungere manualmente la vista al container in un secondo momento, ad esempio utilizzando container.addView(view).
Di seguito troverai un esempio dettagliato che mostra come condividere un Fragment tra due Activity utilizzando un Bundle (vedi paragrafo precedente) per passare dati tra di esse.
Con questo esempio, le due Activity (MainActivity e SecondaActivity) condividono lo stesso Fragment (FragmentCondiviso). Ogni Activity passa un testo diverso al Fragment attraverso un Bundle, che viene poi visualizzato nel TextView all’interno del Fragment.
Architettura MVVM
MVVM è un pattern architetturale Model–View–ViewModel. È stato introdotto per la prima volta da Microsoft e successivamente è diventato molto popolare nel mondo dello sviluppo Android. Questo pattern è utile per separare la logica di presentazione dell’app dalla logica di business, rendendo il codice più manutenibile, testabile e comprensibile.
- Model:
- Rappresenta la logica di business e i dati dell’applicazione.
- Solitamente, il Model interagisce con un database, una API o qualsiasi altro sorgente di dati.
- View:
- È responsabile della presentazione dei dati all’utente e della gestione delle interazioni dell’utente.
- Nell’ambito di Android, la View è spesso rappresentata da un’Activity o da un Fragment.
- ViewModel:
- Funge da intermediario tra il Model e la View.
- Contiene la logica di presentazione e mantiene lo stato dell’UI.
- Esso non dovrebbe contenere riferimenti diretti alla View, rendendo il codice più indipendente e testabile.
- Espone i dati osservabili che la View può “osservare” per essere notificata di eventuali cambiamenti.
Il prossimo esempio implementa l’ architettura MVVM per un modello Studenti gestendo una semplice logica di presentazione dei dati attraverso un form:
In questo esempio abbiamo:
- Studenti rappresenta il Model con i dati dello studente
- ViewModel Studenti è il ViewModel che gestisce la logica e i dati degli studenti
- MainActivity è la View che mostra i dati degli studenti ed interagisce con il ViewModel
Andiamo a descrivere l’ implementazione della MainActivity:
- ViewModelProvider è una classe fornita da AndroidX Lifecycle Library che facilita la creazione e la gestione dei
ViewModelall’interno delle applicazioni Android. È utilizzata per ottenere istanze diViewModele gestire il ciclo di vita delViewModelin relazione al ciclo di vita dell’Activity o del Fragment che lo utilizza. - observe() questo metodo permette di osservare i cambiamenti nei dati emessi da un oggetto e di eseguire azioni reattive quando questi cambiano. È un componente chiave nel design pattern MVVM (Model–View–ViewModel) per sincronizzare e aggiornare l’interfaccia utente in risposta ai cambiamenti nei dati.