Todo lo que necesita saber sobre los componentes de la arquitectura de Android

Componentes de la arquitectura

La arquitectura es un plan constante que debe realizarse antes de que comience el proceso de desarrollo. Los componentes de la arquitectura mantienen la aplicación organizada, unen todos los componentes y proporcionan una colección de bibliotecas que le ayudan a diseñar aplicaciones robustas, verificables y fáciles de mantener. La nueva arquitectura de Android sugiere algunos principios clave para crear una aplicación ideal con seguridad y evitar clases infladas que son difíciles de mantener y probar.

Bloques de construcción

Los ejemplos básicos de bloques de construcción son Actividad, Vista, Intenciones, Servicios, Fragmentos, Archivo de manifiesto, AVD (Dispositivo virtual Android). Estos bloques son la representación de la arquitectura de componentes de la aplicación racional y también son marcas de los puntos débiles del desarrollador.

El primer juego te ayuda con

• Administre automáticamente su actividad y fragmente los ciclos de vida para evitar pérdidas de memoria y recursos
• Conservar objetos de datos Java en una base de datos SQLite

Componentes:

1. Componentes del ciclo de vida

Este componente se utiliza para aumentar la conciencia del ciclo de vida. Los componentes del ciclo de vida incluyen Lifecycle, LifecycleOwner y LifecycleObserver

Ciclo vital

Hasta ahora, el ciclo de vida es una clase abstracta administrada por el propio sistema. Pero en el escenario actual, el ciclo de vida identifica el estado del componente y se comporta y finaliza la tarea en consecuencia en el momento adecuado.

LifecycleOwner

LifecycleOwner es una interfaz que se puede implementar para obtener un objeto de ciclo de vida del método getLifecycle (). ProcessLifecycleOwner es útil cuando desea administrar el ciclo de vida de un proceso completo.

LifecycleObserver

LifecycleObserver observa componentes de LifecycleOwner como actividades y fragmentos. Recibe LifecycleOwner.Event y reacciona a ellos a través de los métodos de anotación.

Al implementar todo esto en conjunto, podemos crear una aplicación compatible con el ciclo de vida.

• Implementando el observador del ciclo de vida

 TestObserver de clase pública implementa LifecycleObserver {

public MyObserver (ciclo de vida del ciclo de vida) {

// Inicia la observación del ciclo de vida

lifecycle.addObserver (esto);

...

}

// Métodos anotados llamados cuando el ciclo de vida asociado pasa por estos eventos

@OnLifecycleEvent (Lifecycle.Event.ON_RESUME)

public void onResume () {

}

@OnLifecycleEvent (Lifecycle.Event.ON_PAUSE)

public void onPause () {

}

}

Ahora podemos usar este observador en nuestro componente de aplicación, usando la siguiente implementación TestObserver observer = new TestObserver (aLifecycleOwner.getLifecycle ());

2. LiveData

El componente LiveData es un contenedor de datos que contiene un valor que se puede observar. Con datos en vivo, cada vez que se actualice la Actividad o el Fragmento, se nos notificará para que su interfaz de usuario esté siempre actualizada. Es un envoltorio alrededor de sus modelos típicos que notifica a los observadores cuando algo cambia en ese modelo. La principal ventaja de livedata es que no hay más pérdidas de memoria y NullPointerExceptions debido a vistas inexistentes.

• Crear objetos LiveData

 La clase pública MyViewModel extiende ViewModel {
// Crea un LiveData con una cadena
private MutableLiveData <String> mData;
public MutableLiveData <String> getData () {
if (mData == null) {
mData = new MutableLiveData <String> ();
}
return mData;
}
}

• Observar objetos LiveData

 El siguiente código ilustra cómo observar el objeto LiveData:
public class MyActivity extiende AppCompatActivity {
public void onCreate (Bundle SavedInstanceState) {
super.onCreate (SavedInstanceState);
Modelo MyViewModel = ViewModelProviders.of (this) .get (MyViewModel .class);
model.getData (). observe (esto, datos -> {
// actualizar la interfaz de usuario
});
}
}

3. Ver modelo

ViewModel es útil para proporcionar y mantener datos para los componentes de la interfaz de usuario (actividad o fragmento) de una manera consciente del ciclo de vida. Es capaz de sobrevivir a los cambios de configuración. Entonces, si destruye la actividad o cambia la orientación de su teléfono, no perderá ViewModel ni los datos. Debido a la instancia de LiveData que se coloca en la clase ViewModel, la entrada de nuestro extremo no es necesaria.

No necesita preocuparse por el ciclo de vida de la interfaz de usuario de los datos del titular en la interfaz de usuario. ViewModel se construirá automáticamente a través de una fábrica y no es necesario que se encargue de crearlo y demolerlo por su cuenta.

• Implementar un modelo de vista

 Está ilustrado por el siguiente código de muestra:
La clase pública MyViewModel extiende ViewModel {
estudiantes privados de MutableLiveData <List <Students>>;
public LiveData <List <Students>> getStudents () {
si (estudiantes == nulo) {
estudiantes = new MutableLiveData <Lista <Estudiantes>> ();
loadStudents ();
}
estudiantes de regreso;
}
private void loadStudents () {
// Realice una operación asincrónica para buscar estudiantes.
}
}

Puede acceder a esta lista desde una actividad de la siguiente manera:

 public class MyActivity extiende AppCompatActivity {
public void onCreate (Bundle SavedInstanceState) {
// Cree un ViewModel la primera vez que el sistema llame al método onCreate () de una actividad.
// Las actividades recreadas reciben la misma instancia de MyViewModel creada por la primera actividad.
Modelo MyViewModel = ViewModelProviders.of (this) .get (MyViewModel.class);
model.getStudents () .observe (esto, estudiantes -> {
// actualizar la interfaz de usuario
});
}
}

4. Habitación

Room es una biblioteca de base de datos y una gran alternativa para la base de datos SQLite. Para utilizar la base de datos SQLite, siempre es necesario escribir mucho texto repetitivo. Podemos definir la base de datos agregando anotaciones en la clase Modelo. La biblioteca ayuda a crear un caché de datos de la aplicación en un dispositivo. Es muy similar a OrmLite.

Hay 3 componentes principales en Room:

una. Base de datos

Como su aplicación persiste, los datos relacionales y contienen el titular de la base de datos, Sirve como el punto de acceso principal para la conexión subyacente a la clase que está anotada con @Database debe satisfacer las siguientes condiciones:

Sea una clase abstracta que amplíe RoomDatabase.

Incluya la lista de entidades conectadas con la base de datos que incorpora la anotación.

Devuelve la clase que está anotada con @Dao y contiene un método abstracto que tiene 0 argumentos.

Mientras está en tiempo de ejecución, puede obtener una instancia de la base de datos llamando a Room.inMemoryDatabaseBuilder () o bien Room.databaseBuilder ().

B. Entidad

Representa una tabla dentro de la base de datos.

C. DAO

Contiene los métodos utilizados para acceder a la base de datos.

• Creando entidad

 @Entidad
Usuario de clase pública {
@Clave primaria
uid int privado;
@ColumnInfo (nombre = "primer_nombre")
Private String firstName;
@ColumnInfo (nombre = "apellido")
private String lastName;

// Los getters y setters se ignoran por brevedad,
// pero son necesarios para que Room funcione.
}

• Crear base de datos

 @Database (entidades = {User.class}, versión = 1)
AppDatabase de clase abstracta pública extiende RoomDatabase {
INSTANCIA de AppDatabase estática privada;
getDatabase público estático AppDatabase (contexto de contexto) {
si (INSTANCIA == nulo) {
INSTANCIA = Room.databaseBuilder (context.getApplicationContext (), AppDatabase.class, "my_db"). Build ();
}
volver INSTANCIA;
}
}

Esta clase se usa para crear la base de datos y obtener una instancia de ella. Creamos la base de datos usando el siguiente código.

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

• Crear el objeto de acceso a datos

Anote la clase con la anotación @Dao. Luego, Room generará una implementación de clase que implementa los métodos definidos en la interfaz (muy similar a cómo funciona Retrofit).

 @Dao
UserDao de interfaz pública {
@Query ("SELECCIONAR * DEL usuario")
List <User> getAll ();
@Query ("SELECT * FROM user WHERE uid IN (: userIds)")
List <User> loadAllByIds (int [] userIds);

@Query ("SELECT * FROM user WHERE first_name LIKE: first AND"
+ "apellido LIKE: último LIMIT 1")
Usuario findByName (cadena primero, cadena última);

@Insertar
void insertAll (Usuario ... usuarios);

@Borrar
anular la eliminación (usuario usuario);
}

Conclusión

Este artículo le brinda un conocimiento básico de los componentes de la arquitectura de Android. Hemos tratado de incluir todos los temas relacionados con la arquitectura de Android recientemente propuesta que resuelve todos los problemas relevantes que enfrenta el desarrollador durante el desarrollo de la aplicación. Aún así, si encuentra algún problema, considere la posibilidad de contratar al desarrollador de Android de la tecnología Elsner .