Tutto quello che devi sapere sui componenti dell'architettura Android

Componenti dell'architettura

L'architettura è un piano stabile che deve essere realizzato prima che inizi il processo di sviluppo. I componenti dell'architettura mantengono l'applicazione organizzata, collegano tutti i componenti e forniscono una raccolta di librerie che aiutano a progettare applicazioni robuste, verificabili e gestibili. La nuova architettura di Android suggerisce alcuni principi chiave per creare un'applicazione ideale con sicurezza ed evitare classi gonfiate che sono difficili da mantenere e testare.

Costruzioni

Esempi di base per i blocchi predefiniti sono Attività, Visualizzazione, Intenti, Servizi, Frammenti, File manifest, AVD (dispositivo virtuale Android). Questi blocchi sono la rappresentazione dell'architettura dei componenti dell'applicazione razionale e sono anche segni di punti deboli dello sviluppatore.

Il primo set ti aiuta con

• Gestisci automaticamente la tua attività e frammenta i cicli di vita per evitare perdite di memoria e risorse
• Mantieni oggetti dati Java su un database SQLite

Componenti:

1. Componenti del ciclo di vita

Questo componente viene utilizzato per aggiungere la consapevolezza del ciclo di vita. I componenti del ciclo di vita includono Lifecycle, LifecycleOwner e LifecycleObserver

Ciclo vitale

Finora il ciclo di vita è una classe astratta gestita dal sistema stesso. Ma nello scenario attuale, Lifecycle identifica lo stato del componente e si comporta e termina l'attività di conseguenza al momento opportuno.

Proprietario del ciclo di vita

LifecycleOwner è un'interfaccia che può implementare per ottenere un oggetto del ciclo di vita dal metodo getLifecycle(). ProcessLifecycleOwner è utile quando si desidera gestire il ciclo di vita di un intero processo.

Lifecycle Observer

LifecycleObserver osserva i componenti LifecycleOwner come Attività e Frammenti. Riceve LifecycleOwner.Event e reagisce ad essi tramite i metodi di annotazione.

Implementando tutto questo insieme, possiamo creare un'applicazione consapevole del ciclo di vita.

• Implementazione dell'osservatore del ciclo di vita

 public class TestObserver implementa LifecycleObserver {

public MyObserver (ciclo di vita del ciclo di vita) {

// Avvia l'osservazione del ciclo di vita

ciclo di vita.addObserver(this);

...

}

// Metodi annotati chiamati quando il ciclo di vita associato passa attraverso questi eventi

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

public void onResume() {

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

public void onPause() {

}

}

Ora possiamo usare questo osservatore nel nostro componente app, usando la seguente implementazione TestObserver osservatore = new TestObserver(aLifecycleOwner.getLifecycle());

2. Dati in tempo reale

Il componente LiveData è un titolare di dati che contiene un valore che può essere osservato. Con livesata ogni volta che Activity o Fragment vengono aggiornati, riceveremo una notifica in modo che la tua interfaccia utente sia sempre aggiornata. È un involucro attorno ai tuoi modelli tipici che avvisa gli osservatori quando qualcosa cambia in quel modello. Il vantaggio principale di livesata è non più perdite di memoria e NullPointerExceptions dovute a visualizzazioni inesistenti.

• Crea oggetti LiveData

 public class MyViewModel estende ViewModel {
// Crea un LiveData con una stringa
privato MutableLiveData<String> mData;
public MutableLiveData<String> getData() {
if (mData == null) {
mData = new MutableLiveData<String>();
}
restituire mData;
}
}

• Osserva gli oggetti LiveData

 Il codice seguente illustra come osservare l'oggetto LiveData:
public class MyActivity estende AppCompatActivity {
public void onCreate (Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyViewModel model = ViewModelProviders.of(this).get(MyViewModel .class);
model.getData().observe(this, data -> {
// aggiorna l'interfaccia utente
});
}
}

3. Visualizza modello

ViewModel utile per fornire e mantenere i dati per i componenti dell'interfaccia utente (Attività o Frammento) in modo consapevole del ciclo di vita. È in grado di sopravvivere attraverso le modifiche alla configurazione. Quindi, se distruggi l'attività o cambi l'orientamento del telefono, non perderai ViewModel e dati. A causa dell'istanza LiveData posizionata nella classe ViewModel, l'input da parte nostra non è richiesto.

Non devi preoccuparti del ciclo di vita dell'interfaccia utente dei dati del titolare nell'interfaccia utente. ViewModel sarà costruito automaticamente attraverso una fabbrica e non dovrai occuparti di crearlo e demolirlo da solo.

• Implementa un ViewModel

 È illustrato dal seguente codice di esempio:
public class MyViewModel estende ViewModel {
private MutableLiveData<List<Studenti>> studenti;
public LiveData<List<Students>> getStudents () {
if (studenti == null) {
studenti = new MutableLiveData<List<Studenti>>();
loadStudents();
}
studenti di ritorno;
}
private void loadStudents () {
// Esegue un'operazione asincrona per recuperare gli studenti.
}
}

È possibile accedere a questo elenco da un'attività come segue:

 public class MyActivity estende AppCompatActivity {
public void onCreate (Bundle savedInstanceState) {
// Crea un ViewModel la prima volta che il sistema chiama il metodo onCreate() di un'attività.
// Le attività ricreate ricevono la stessa istanza MyViewModel creata dalla prima attività.
MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
model.getStudents().observe(this, studenti -> {
// aggiorna l'interfaccia utente
});
}
}

4. Stanza

Room è una libreria di database e un'ottima alternativa al database SQLite. Per utilizzare il database SQLite è sempre necessario scrivere molto boilerplate. Possiamo definire il database aggiungendo annotazioni nella classe Model. La libreria aiuta a creare una cache dei dati dell'app su un dispositivo. È molto simile a OrmLite.

Ci sono 3 componenti principali in Room:

un. Banca dati

Poiché la tua app è persistente, i dati relazionali e contengono il titolare del database, funge da punto di accesso principale per la connessione sottostante alla classe annotata con @Database dovrebbe soddisfare le seguenti condizioni:

Sii una classe astratta che estende RoomDatabase.

Includere l'elenco delle entità collegate al database che incorpora l'annotazione.

Restituisce la classe annotata con @Dao e contiene un metodo astratto che ha 0 argomenti.

Durante l'esecuzione, è possibile ottenere un'istanza del database chiamando Room.inMemoryDatabaseBuilder() oppure Room.databaseBuilder().

B. Entità

Rappresenta una tabella all'interno del database.

C. DAO

Contiene i metodi utilizzati per accedere al database.

• Creazione di entità

 @Entità
Utente di classe pubblica {
@Chiave primaria
int uid privato;
@ColumnInfo(name = "first_name")
private String firstName;
@ColumnInfo(name = "cognome")
cognome stringa privato;

// Getter e setter vengono ignorati per brevità,
// ma sono necessari per il funzionamento di Room.
}

• Crea database

 @Database(entità = {User.class}, versione = 1)
la classe astratta pubblica AppDatabase estende RoomDatabase {
ISTANZA AppDatabase statico privato;
public static AppDatabase getDatabase(Context context) {
if (ISTANZA == nullo) {
ISTANZA = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "my_db").build();
}
ISTANZA di ritorno;
}
}

Questa classe viene utilizzata per creare il database e ottenerne un'istanza. Creiamo il database utilizzando il seguente codice.

Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, “my_db”).build();

• Crea l'oggetto di accesso ai dati

Annota la classe con l'annotazione @Dao. Un'implementazione di classe verrà quindi generata da Room che implementa i metodi definiti nell'interfaccia (molto simile a come funziona Retrofit).

 @Dao
interfaccia pubblica UserDao {
@Query("SELECT * FROM utente")
Lista<Utente> getAll();
@Query("SELECT * FROM utente WHERE uid IN (:userIds)")
List<User> loadAllByIds(int[] userIds);

@Query("SELECT * FROM utente WHERE first_name LIKE :first AND "
+ "cognome MI PIACE: ultimo LIMITE 1")
Utente findByName (prima stringa, ultima stringa);

@Inserire
void insertAll(Utente... utenti);

@Eliminare
void delete(Utente utente);
}

Conclusione

Questo articolo fornisce una conoscenza di base dei componenti dell'architettura Android. Abbiamo cercato di includere tutti gli argomenti relativi alla nuova architettura Android proposta che risolvono tutti i problemi rilevanti che vengono affrontati dallo sviluppatore durante lo sviluppo dell'applicazione. Tuttavia, se riscontri problemi, prendi in considerazione l' assunzione di uno sviluppatore Android di Elsner Technology .