ViewModel e LiveData

Uno degli elementi centrali dell'Android Architecture Components è il ViewModel. Questo termine identifica un componente destinato alla gestione dei dati dell'interfaccia utente compatibilmente con il ciclo di vita dell'applicazione. Quest'ultimo aspetto è di fondamentale importanza e rende il ViewModel qualcosa di molto diverso
da un semplice contenitore di oggetti. In questa lezione, vedremo i passaggi che portano all'integrazione di un
ViewModel in un'app a livello di linee guida, sottolineando il ruolo rivestito dai LiveData, altro elemento fondamentale agli scopi della nuova piattaforma.

Perchè serve il ViewModel?

Come primo passaggio, approfondiamo le motivazioni che hanno portato alla concezione del ViewModel. Per farlo, è necessario ripercorrere alcuni punti
cardine dello sviluppo di app Android:

• i componenti dedicati alla gestione dell'interfaccia utente sono Activity e Fragment che svolgono il ruolo di
  controller;
• i dati che popolano le interfacce utente sono transienti (conservati in oggetti temporanei, tipicamente
  variabili d'istanza di Activity e Fragment) e spesso frutto di un caricamento oneroso da database o da fonti remote;
• alcuni passaggi da una fase all'altra del ciclo di vita indotti da cambi di configurazione (ad esempio, rotazione del dispositivo) o altri eventi hanno come conseguenza la distruzione dell'Activity, che ne rende necessaria la successiva ricostruzione;
• ogni volta che le Activity vengono distrutte, i dati transienti vanno persi ed eventuali loro caricamenti vengono ripetuti se svolti all'interno dell'Activity.

Quanto prospettato all'ultimo punto rischia di penalizzare la consistenza dei dati e le prestazioni dell'applicazione. Secondo i classici approcci, si dovrebbe ricorrere al salvataggio dello stato dell'applicazione tramite il metodo onSaveInstanceState()
(ideale, però, solo per piccole quantità di dati) per la tutela dei dati transienti e alla delocalizzazione di caricamento di dati tramite attività asincrone svolte da Loader e Service. Tutte queste necessità, da ora, possono essere esaudite organizzando il codice in una
sola componente: il ViewModel, appunto.

Come importare il ViewModel

Per importare il ViewModel è necessario seguire i due passi già menzionati in questa sezione della guida:

• • aggiungiamo, nel file build.gradle del progetto, il metodo che permette di recuperare componenti dai repository di Google:

allprojects {
repositories {
jcenter()
google()
}
}

• • includiamo, nel file build.gradle del modulo, le dipendenze necessarie:

dependencies {
...
...
implementation "android.arch.lifecycle:extensions:1.0.0"
annotationProcessor "android.arch.lifecycle:compiler:1.0.0"
...
...
}

Con questi passaggi includiamo non solo il ViewModel, ma anche tutto il necessario per usare i LiveData.

Integrazione di un ViewModel in un'Activity

Un ViewModel viene valorizzato se lavora usando oggetti LiveData. Si tratta di observable
che sopravvivono all'andamento del ciclo di vita.

Un ViewModel:

• nasce come estensione della classe ViewModel;
• mantiene oggetti LiveData come variabili d'istanza. Questi dati popoleranno l'interfaccia utente;
• offre metodi getter per la restituzione di dati, in modo da poterli leggere dall'Activity;
• contiene metodi per l'aggiornamento dei LiveData. Qui potremo inserire operazioni di recupero di dati da altre fonti (database, rete, file, etc.)
  che andranno svolte in modalità asincrona.

Quello che segue è lo schema generale di una classe ViewModel, che gestisce un oggetto LiveData myObject di un'ipotetica classe MyClass (nel codice sarà
da sostituire con una classe di proprio interesse):

public class UiDataViewModel extends ViewModel {
// variabile d'istanza di tipo LiveData
private MutableLiveData<MyClass> myObject;
// getter per la variabile d'istanza
public LiveData<MyClass> getMyObject() {
if (myObject == null) {
myObject = new MutableLiveData<MyClass>();
// aggiornamento dell'oggetto myObject
updateMyObject();
}
return myObject;
}
private void updateMyObject() {
// aggiorna in modalità asincrona myObject
}
}

All'interno dell'Activity, dovremo:

• ottenere un riferimento al ViewModel, non istanziandolo con new ma utilizzando la classe ViewModelProviders;
• invocare il metodo getter predisposto nel ViewModel per ottenere un LiveData da usare per aggiornare l'interfaccia utente ogni volta che ce ne sarà bisogno.

Tradutto in Java, quanto appena detto è riassunto dal codice seguente:

public class UiActivity extends AppCompatActivity {
public void onCreate(Bundle savedInstanceState) {
// riferimento al ViewModel
UiDataViewModel model = ViewModelProviders.of(this).get(UiDataViewModel.class);
model.getMyObject().observe(this, new Observer<MyClass>() {
@Override
public void onChanged(@Nullable MyClass s) {
/*
* aggiornamento dell'interfaccia utente con i
* dati provenienti dall'oggetto LiveData
*/
}
}
);
}
}

Viste le motivazioni di base che hanno portato all'introduzione del ViewModel e dei LiveData, non ci resta che passare ad un esempio pratico, che sarà oggerrot della prossima lezione.