Architettura MVVM per Android

Srinivasa Sainath -

Nell'ingegneria del software, un design pattern è un problema comunemente presente nella progettazione del software. Un modello di progettazione non è un progetto finale che può essere trasformato direttamente in codice risolto.

Uno dei problemi principali nello sviluppo del software è lo stretto accoppiamento del codice, vale a dire che anche un piccolo cambiamento in una porzione di codice comporta modifiche o bug in un'altra parte del codice. Il codice non è compatibile con i test unitari e non è riutilizzabile.

Introduzione

Attualmente sono disponibili molti approcci architetturali come MVP, FLUX, MVI, MVVM che risolvono i problemi di cui sopra. Possiamo utilizzare qualsiasi approccio per mantenere correttamente il nostro codice in modo che tutto funzioni bene, in breve, una vita felice per gli sviluppatori. Questo articolo discute il design pattern MVVM in Android e come possiamo risolvere i problemi esistenti con il design pattern MVVM.

I componenti principali del design pattern MVVM sono :

  1. Vista - Informa il ViewModel sulle azioni dell'utente
  2. ViewModel - Espone i flussi di dati rilevanti per la vista.
  3. DataModel - Astrae l'origine dei dati. Il ViewModel lavora con il DataModel per ottenere e salvare i dati.

Breve spiegazione del modello di progettazione MVVM

Google ha introdotto i componenti dell'architettura Android, che includevano ViewModel anziché Presenter e quindi la prova che anche Google supporta MVVM.

Modello di vista

I ViewModel sono semplici classi che interagiscono con il livello logico/modello ed espongono stati/dati, senza sapere da chi o come verranno consumati. Solo View(Activity) fa riferimento a ViewModel e non viceversa; questo risolve il problema dell'accoppiamento stretto. Una singola vista può avere un riferimento a più ViewModel.

➡️
public class MainViewModel extends ViewModel {public MainViewModel() {}public String getText() {return new DataModel().getText();}}View

In Android, l'attività rappresenta una vista nel design pattern MVVM. La vista è responsabile della visualizzazione delle applicazioni e dei dati immessi dagli utenti. Questa parte non deve elaborare i dati in nessun caso. La sua funzione è solo quella di rilevare gli input, come il tocco o lo scorrimento, e di visualizzarli.

Il modello architettonico ModelView-ViewModel è stato introdotto in Android con la nascita della libreria DataBinding. È possibile abilitare il data-binding dal file app.gradle.

➡️
dataBinding{enabled = true}

Add these lines in-app.Gradle inside android{} tag. Then put your XML layout code under tag. This will generate a binding class, and you can access this class from the activity. You can see we can directly access the getText() method from XML.

➡️
<?xml version="1.0" encoding="utf-8"?><layout><data><variablename="mainViewModel"type="com.g.mvvmproject.MainViewModel" /></data><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"tools:context=".MainActivity"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{mainViewModel.text}"app:layout_constraintBottom_toBottomOf="parent"app:layout_constraintLeft_toLeftOf="parent"app:layout_constraintRight_toRightOf="parent"app:layout_constraintTop_toTopOf="parent" /></RelativeLayout></layout>

Dopo l'inattività di setContentView si imposta un riferimento al modello di vista.

➡️
public class MainActivity extends AppCompatActivity {private ActivityMainBinding mActivityMainBinding;private MainViewModel mainViewModel;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);mActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);mainViewModel = new MainViewModel();mActivityMainBinding.setMainViewModel(mainViewModel);}}

Modello di dati

Il DataModel contiene i dati dell'applicazione. Non può parlare direttamente con la vista. In genere, si consiglia di esporre i dati al ViewModel attraverso gli Observables.

➡️
public class DataModel {String text="Hello World ";public String getText() {return text + text;}}

Vantaggi dell'utilizzo del design pattern MVVM

  • La testabilità del codice aumenta.

Nel frammento di codice seguente, viene testato il metodo getText() nel ViewModel. È possibile prendere in giro i propri dati e verificare il risultato atteso.

➡️
@RunWith(AndroidJUnit4.class)public class ExampleInstrumentedTest {@Testpublic void emailValidator_CorrectEmailSimple_ReturnsTrue() {String expected = "Hello World Hello World ";assertEquals(expected, new MainViewModel().getText());}}
  • Il codice è disaccoppiato.
  • La struttura dei pacchetti è ancora più facile da navigare.
  • Il progetto è ancora più facile da mantenere.
  • Il vostro team può aggiungere nuove funzionalità ancora più rapidamente.

Conclusione

MVVM combina i vantaggi della separazione delle preoccupazioni forniti da MVP, sfruttando al contempo i vantaggi dei data binding. Il risultato è un modello in cui il modello guida il maggior numero possibile di operazioni, riducendo al minimo la logica della vista.

➡️
Un semplice esempio di implementazione di MVVM si trova qui.

‍