Tudo o que você precisa saber sobre os componentes de arquitetura do Android

Componentes de Arquitetura

A arquitetura é um plano constante que precisa ser feito antes do início do processo de desenvolvimento. Os componentes de arquitetura mantêm os aplicativos organizados, unem todos os componentes e fornecem uma coleção de bibliotecas que o ajudam a projetar aplicativos robustos, verificáveis ​​e de fácil manutenção. A nova arquitetura do Android sugere alguns princípios-chave para criar um aplicativo ideal com segurança e evitar classes inchadas que são difíceis de manter e testar.

Blocos de construção

Exemplos básicos de blocos de construção são Activity, View, Intents, Services, Fragments, Manifest File, AVD (Android Virtual Device). Esses blocos são a representação da arquitetura de componente do aplicativo racional e também são marcas dos pontos problemáticos do desenvolvedor.

O primeiro conjunto ajuda você com

• Gerencie automaticamente sua atividade e ciclos de vida de fragmentos para evitar vazamentos de memória e recursos
• Persistir objetos de dados Java em um banco de dados SQLite

Componentes:

1. Componentes do ciclo de vida

Este componente é usado para adicionar consciência de ciclo de vida. Os componentes do Lifecycle incluem Lifecycle, LifecycleOwner e LifecycleObserver

Ciclo da vida

Até agora, o ciclo de vida é uma classe abstrata gerenciada pelo próprio sistema. Mas no cenário atual, o Lifecycle identifica o estado do componente e se comporta e finaliza a tarefa de acordo no momento apropriado.

LifecycleOwner

LifecycleOwner é uma interface que pode ser implementada para obter um objeto de ciclo de vida do método getLifecycle (). ProcessLifecycleOwner é útil quando você deseja gerenciar o ciclo de vida de um processo inteiro.

LifecycleObserver

LifecycleObserver observa componentes LifecycleOwner como Activities e Fragments. Ele recebe LifecycleOwner.Event e reage a eles por meio dos métodos de anotação.

Implementando isso todos juntos, podemos criar um aplicativo que reconhece o ciclo de vida.

• Observador de implementação do ciclo de vida

 public class TestObserver implementa LifecycleObserver {

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

// Inicia a observação do ciclo de vida

lifecycle.addObserver (this);

...

}

// Métodos anotados chamados quando o ciclo de vida associado passa por esses eventos

@OnLifecycleEvent (Lifecycle.Event.ON_RESUME)

public void onResume () {

}

@OnLifecycleEvent (Lifecycle.Event.ON_PAUSE)

public void onPause () {

}

}

Agora podemos usar este observador em nosso componente de aplicativo, usando a seguinte implementação TestObserver observer = new TestObserver (aLifecycleOwner.getLifecycle ());

2. LiveData

O componente LiveData é um portador de dados que contém um valor que pode ser observado. Com liveata sempre que Activity ou Fragment for atualizado, seremos notificados para que sua IU esteja sempre atualizada. É um invólucro em torno de seus modelos típicos que notificam os observadores quando algo muda nesse modelo. A principal vantagem do liveata é o fim de vazamentos de memória e NullPointerExceptions devido a visualizações inexistentes.

• Crie objetos LiveData

 public class MyViewModel extends ViewModel {
// Crie um LiveData com uma String
private MutableLiveData <String> mData;
public MutableLiveData <String> getData () {
if (mData == null) {
mData = novo MutableLiveData <String> ();
}
return mData;
}
}

• Observe objetos LiveData

 O código a seguir ilustra como observar o objeto 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 -> {
// atualizar IU
});
}
}

3. Ver modelo

ViewModel é útil para fornecer e manter dados para seus componentes de IU (Activity ou Fragment) de uma maneira consciente do ciclo de vida. É capaz de sobreviver às mudanças de configuração. Portanto, se você destruir a atividade ou alterar a orientação do telefone, não perderá ViewModel e dados. Devido à instância LiveData que é colocada na classe ViewModel, a entrada de nossa extremidade não é necessária.

Você não precisa se preocupar com o ciclo de vida da IU dos dados do titular na IU. ViewModel será construído automaticamente através de uma fábrica e você não precisa lidar com sua criação e demolição por conta própria.

• Implementar um ViewModel

 É ilustrado pelo seguinte código de amostra:
public class MyViewModel extends ViewModel {
Private MutableLiveData <List <Students>> alunos;
public LiveData <List <Students>> getStudents () {
if (alunos == null) {
alunos = novo MutableLiveData <List <Students>> ();
loadStudents ();
}
alunos de retorno;
}
private void loadStudents () {
// Faça uma operação assíncrona para buscar alunos.
}
}

Você pode acessar essa lista a partir de uma atividade da seguinte maneira:

 public class MyActivity estende AppCompatActivity {
public void onCreate (Bundle savedInstanceState) {
// Crie um ViewModel na primeira vez que o sistema chamar o método onCreate () de uma atividade.
// Atividades recriadas recebem a mesma instância MyViewModel criada pela primeira atividade.
MyViewModel model = ViewModelProviders.of (this) .get (MyViewModel.class);
model.getStudents () .observe (this, students -> {
// atualizar IU
});
}
}

4. Sala

Room é uma biblioteca de banco de dados e uma ótima alternativa para banco de dados SQLite. Para usar o banco de dados SQLite é sempre necessário escrever um monte de boilerplate. Podemos definir o banco de dados adicionando anotações na classe Model. A biblioteca ajuda a criar um cache de dados do aplicativo em um dispositivo. É muito semelhante ao OrmLite.

Existem 3 componentes principais na sala:

uma. Base de dados

Como seu aplicativo é persistido, os dados relacionais e contém o detentor do banco de dados, ele serve como o principal ponto de acesso para a conexão subjacente à classe que está anotada com @Database deve satisfazer as seguintes condições:

Seja uma classe abstrata que estende RoomDatabase.

Inclui a lista de entidades conectadas ao banco de dados que incorpora a anotação.

Ele retorna a classe anotada com @Dao e contém um método abstrato com 0 argumentos.

Durante o tempo de execução, você pode obter uma instância do banco de dados chamando Room.inMemoryDatabaseBuilder () ou Room.databaseBuilder ().

b. Entidade

Representa uma tabela no banco de dados.

c. DAO

Contém os métodos usados ​​para acessar o banco de dados.

• Criando entidade

 @Entidade
public class User {
@Chave primária
int uid privado;
@ColumnInfo (name = "first_name")
private String firstName;
@ColumnInfo (name = "last_name")
private String lastName;

// Getters e setters são ignorados por questões de brevidade,
// mas eles são necessários para que o Room funcione.
}

• Criar banco de dados

 @Database (entidades = {User.class}, versão = 1)
public abstract class AppDatabase extends RoomDatabase {
AppDatabase privado estático INSTANCE;
public static AppDatabase getDatabase (Context context) {
if (INSTANCE == null) {
INSTANCE = Room.databaseBuilder (context.getApplicationContext (), AppDatabase.class, "my_db"). Build ();
}
return INSTANCE;
}
}

Esta classe é usada para criar o banco de dados e obter uma instância dele. Nós criamos o banco de dados usando o seguinte código.

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

• Crie o objeto de acesso a dados

Anote a classe com a anotação @Dao. Uma implementação de classe será então gerada pela Room que implementa os métodos definidos na interface (muito semelhante a como funciona o Retrofit).

 @Dao
interface pública UserDao {
@Query ("SELECT * FROM user")
Listar <User> getAll ();
@Query ("SELECT * FROM user WHERE uid IN (: userIds)")
Listar <User> loadAllByIds (int [] userIds);

@Query ("SELECT * FROM user WHERE first_name LIKE: first AND"
+ "last_name LIKE: último LIMIT 1")
User findByName (String primeiro, String por último);

@Inserir
void insertAll (usuário ... usuários);

@Excluir
void delete (usuário usuário);
}

Conclusão

Este artigo fornece um conhecimento básico dos componentes da arquitetura do Android. Tentamos incluir todos os tópicos relacionados à arquitetura Android recém-proposta, que resolvem todos os problemas relevantes enfrentados pelo desenvolvedor durante o desenvolvimento do aplicativo. Ainda assim, se você encontrar algum problema, considere contratar desenvolvedor Android da Elsner Technology .