Una
actividad en Android representa una pantalla la cual es presentada al
usuario. Dependiendo de la complejidad de la aplicación es más
probable el uso de diferentes pantallas se hacen necesarias.
Usualmente
las actividades se encargan del procesamiento de los eventos
disparados por el usuario. Y consisten de fragmentos que permiten que
la Interfaz de Usuario se componga de actividades secundarias. Para
la navegación entre actividades se inicia una nueva actividad. La
mayoría de las Activitys están
diseñadas para ocupar toda la pantalla sin embargo se pueden crea
actividades flotantes o semitransparentes.
Ciclo
de vida de una Activity.
Para
manejar los cambios de estado Android provee una serie de eventos que
son disparados entre cada transición de estado de una actividad. El
ciclo de vida completo
de una actividad es desde el método onCreate hasta el
método onDestroy (cabe aclarar
que muchas actividades son destruidas sin llegar al método
onDestroy); el ciclo de vida visible
de una actividad comprende unicamente los métodos onStart
hasta onStop, y el ciclo de
vida activo de una
actividad va desde el método onResume hasta onPause.
El
siguiente framento de codigo explica los elementos que se colocan
dentro de cada uno de los métodos. Fuente: Professional
Android 4 Application Development.
package com.roque.rueda.helloworld;
import android.app.Activity;
import android.os.Bundle;
/**
* Created by Roque Rueda on 23/06/13.
*/
public class MyStateChangeActivity extends Activity {
// Called at the start of the full lifetime.
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Initialize Activity and inflate the UI.
}
// Called after onCreate has finished, use to restore UI state
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
// Restore UI state from the savedInstanceState.
// This bundle has also been passed to onCreate.
// Will only be called if the Activity has been
// killed by the system since it was last visible.
}
// Called before subsequent visible lifetimes
// for an Activity process.
@Override
public void onRestart(){
super.onRestart();
// Load changes knowing that the Activity has already
// been visible within this process.
}
// Called at the start of the visible lifetime.
@Override
public void onStart(){
super.onStart();
// Apply any required UI change now that the Activity is visible.
}
// Called at the start of the active lifetime.
@Override
public void onResume(){
super.onResume();
// Resume any paused UI updates, threads, or processes required
// by the Activity but suspended when it was inactive.
}
// Called to save UI state changes at the
// end of the active lifecycle.
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
// Save UI state changes to the savedInstanceState.
// This bundle will be passed to onCreate and
// onRestoreInstanceState if the process is
// killed and restarted by the run time.
super.onSaveInstanceState(savedInstanceState);
}
// Called at the end of the active lifetime.
@Override
public void onPause(){
// Suspend UI updates, threads, or CPU intensive processes
// that don’t need to be updated when the Activity isn’t
// the active foreground Activity.
super.onPause();
}
// Called at the end of the visible lifetime.
@Override
public void onStop(){
// Suspend remaining UI updates, threads, or processing
// that aren't required when the Activity isn’t visible.
// Persist all edits or state changes
// as after this call the process is likely to be killed.
super.onStop();
}
// Sometimes called at the end of the full lifetime.
@Override
public void onDestroy(){
// Clean up any resources including ending threads,
// closing database connections etc.
super.onDestroy();
}
}
