Compreendendo as atividades do Android
Neste artigo, exploraremos o que são as atividades do Android , como elas funcionam e como criá-las.
Quando você usa um aplicativo em seu dispositivo Android, o que você está realmente interagindo é uma atividade.
As atividades são os blocos de construção básicos dos aplicativos Android, responsáveis por fornecer uma interface de usuário e lidar com a interação do usuário.
O que é uma Atividade?
Uma atividade é uma tarefa única e focada com a qual o usuário pode interagir. Cada atividade normalmente corresponde a uma tela na interface do usuário do seu aplicativo.
Por exemplo, se você estiver criando um aplicativo de mensagens, poderá ter uma atividade para redigir mensagens, outra para exibir a caixa de entrada do usuário e assim por diante.
Quando o usuário inicia seu aplicativo, o Android cria uma Activity inicial para exibir. A partir daí, o usuário pode navegar para outras atividades em seu aplicativo, seja tocando em botões ou links na interface do usuário ou usando o botão Voltar do dispositivo.
As atividades têm um ciclo de vida, que determina como elas são criadas, iniciadas, pausadas, retomadas, interrompidas e destruídas. Esse ciclo de vida é gerenciado pelo sistema Android e é projetado para otimizar o uso de memória e melhorar o desempenho.
Cada atividade é definida por uma classe Java que estende a classe Activity e geralmente contém um arquivo de layout que define a interface com o usuário para a atividade. As atividades são iniciadas usando intenções, que podem passar dados entre atividades e acionar diferentes atividades com base na entrada do usuário.
Ciclo de vida das atividades do Android
As atividades possuem um ciclo de vida único que é gerenciado pelo sistema Android.
O ciclo de vida inclui vários estados, incluindo:
| estados | Visão geral |
| onCreate() | Este método é chamado quando a atividade é criada. Normalmente é usado para inicializar a atividade e configurar a interface do usuário. |
| onStart() | Este método é chamado quando a atividade se torna visível para o usuário. Normalmente é usado para preparar a atividade a ser exibida. |
| Resumindo() | Este método é chamado quando a atividade está prestes a começar a interagir com o usuário. Normalmente é usado para iniciar animações ou outros efeitos visuais. |
| onPause() | Esse método é chamado quando a atividade não está mais em primeiro plano e outra atividade tomou seu lugar. Normalmente é usado para salvar dados não salvos ou pausar tarefas em andamento. |
| onStop() | Este método é chamado quando a atividade não está mais visível para o usuário. Normalmente é usado para liberar quaisquer recursos ou interromper quaisquer tarefas em andamento. |
| onDestroy() | Este método é chamado quando a atividade está prestes a ser destruída. Normalmente é usado para liberar quaisquer recursos ou executar tarefas de limpeza. |
| onRestart() | O método é invocado quando a atividade é interrompida e reiniciada. No caso de onRestart(), a atividade está parada, mas não foi destruída. |
Aqui está um exemplo do ciclo de vida da atividade no Android:
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(TAG, "onCreate() called");
}
@Override
protected void onStart() {
super.onStart();
Log.d(TAG, "onStart() called");
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, "onResume() called");
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, "onPause() called");
}
@Override
protected void onStop() {
super.onStop();
Log.d(TAG, "onStop() called");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy() called");
}
@Override
protected void onRestart() {
super.onRestart();
Log.d(TAG, "onRestart() called");
}
}
O exemplo acima estende AppCompatActivity e substitui os métodos de ciclo de vida. Ao criar uma atividade, o método onCreate() é chamado, seguido por onStart() e onResume() . OnPause() e onStop() são executados quando a atividade é pausada ou interrompida.
Uma atividade é destruída chamando onDestroy() . Se a atividade for reiniciada, onRestart() , onStart() e onResume() serão invocados nessa ordem.
Log.d() gera mensagens de log para cada método no ciclo de vida da atividade, permitindo que você rastreie o ciclo de vida da atividade e veja quando cada método é chamado.
Iniciando atividades
As atividades podem ser lançadas de várias maneiras. Uma maneira comum é por meio de uma intenção.
Uma intenção é um objeto que descreve uma solicitação para executar uma ação.
As atividades podem ser iniciadas com uma intenção explícita, que especifica a atividade de destino, ou uma intenção implícita, que permite ao sistema escolher a atividade apropriada.
A sintaxe para criar uma intenção explícita no Android é a seguinte:
Intent intent = new Intent(context, TargetActivity.class); startActivity(intent);
Aqui, context é o contexto atual do aplicativo e TargetActivity é a classe da atividade que queremos iniciar.
A sintaxe para criar uma intenção implícita no Android é a seguinte:
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.example.com"));
startActivity(intent);
Aqui, Intent.ACTION_VIEW é a ação que queremos realizar, e Uri.parse(“https://www.example.com”) são os dados que queremos passar para a atividade que irá manipular a intenção.
Gerenciando Transições de Atividade
Transições de atividade ocorrem quando uma atividade inicia outra atividade.
Por padrão, o Android fornece animações definidas pelo sistema para essas transições.
Você também pode personalizar essas animações usando o método overridePendingTransition() .
Aqui está um exemplo de substituição da animação padrão para uma transição de atividade:
Intent intent = new Intent(MainActivity.this, SecondActivity.class); startActivity(intent); overridePendingTransition(R.anim.slide_in_right, R.anim.slide_out_left);
Esse código cria uma nova intenção e inicia a SecondActivity. O método overridePendingTransition() é então chamado, passando dois recursos de animação como parâmetros.
A primeira animação (slide_in_right) é aplicada à nova atividade conforme ela entra na tela, e a segunda animação (slide_out_left) é aplicada à atividade atual conforme ela sai da tela.
