Aquí una compilación de las formas más comunes para lograr esto :
- Enviar datos dentro de la intención
- Campos estáticos
- HashMapa de
WeakReferences
- Objetos persistentes (sqlite, compartir preferencias, archivo, etc.)
TL; DR : hay dos formas de compartir datos: pasar datos en los extras del intento o guardarlos en otro lugar. Si los datos son primitivos, cadenas u objetos definidos por el usuario: envíelos como parte de la intención extras (los objetos definidos por el usuario deben implementarse Parcelable
). Si pasa objetos complejos, guarde una instancia en un singleton en otro lugar y acceda a ellos desde la actividad iniciada.
Algunos ejemplos de cómo y por qué implementar cada enfoque:
Enviar datos dentro de intentos
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);
En la segunda actividad:
Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");
Use este método si está pasando datos primitivos o cadenas . También puede pasar objetos que implemente Serializable
.
Aunque es tentador, debe pensarlo dos veces antes de usarlo Serializable
: es propenso a errores y es terriblemente lento. Entonces, en general: manténgase alejado deSerializable
si es posible. Si desea pasar objetos complejos definidos por el usuario, eche un vistazo a la Parcelable
interfaz . Es más difícil de implementar, pero tiene considerables ganancias de velocidad en comparación Serializable
.
Comparta datos sin persistir en el disco
Es posible compartir datos entre actividades guardándolos en la memoria dado que, en la mayoría de los casos, ambas actividades se ejecutan en el mismo proceso.
Nota: a veces, cuando el usuario abandona su actividad (sin abandonarla), Android puede decidir eliminar su aplicación. En tal escenario, he experimentado casos en los que Android intenta iniciar la última actividad utilizando la intención proporcionada antes de que la aplicación fuera eliminada. En estos casos, los datos almacenados en un singleton (ya sea el suyo oApplication
) desaparecerán y podrían ocurrir cosas malas. Para evitar estos casos, puede conservar los objetos en el disco o verificar los datos antes de usarlos para asegurarse de que sean válidos.
Usa una clase singleton
Tener una clase para guardar los datos:
public class DataHolder {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
private static final DataHolder holder = new DataHolder();
public static DataHolder getInstance() {return holder;}
}
De la actividad lanzada:
String data = DataHolder.getInstance().getData();
Usar aplicación singleton
La aplicación singleton es una instancia de la android.app.Application
cual se crea cuando se inicia la aplicación. Puede proporcionar uno personalizado extendiendo Application
:
import android.app.Application;
public class MyApplication extends Application {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
}
Antes de lanzar la actividad:
MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);
Luego, desde la actividad lanzada:
MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();
Campos estáticos
La idea es básicamente la misma que el singleton, pero en este caso proporciona acceso estático a los datos:
public class DataHolder {
private static String data;
public static String getData() {return data;}
public static void setData(String data) {DataHolder.data = data;}
}
De la actividad lanzada:
String data = DataHolder.getData();
HashMapa de WeakReferences
La misma idea, pero permitiendo que el recolector de basura elimine objetos sin referencia (por ejemplo, cuando el usuario abandona la actividad):
public class DataHolder {
Map<String, WeakReference<Object>> data = new HashMap<String, WeakReference<Object>>();
void save(String id, Object object) {
data.put(id, new WeakReference<Object>(object));
}
Object retrieve(String id) {
WeakReference<Object> objectWeakReference = data.get(id);
return objectWeakReference.get();
}
}
Antes de lanzar la actividad:
DataHolder.getInstance().save(someId, someObject);
De la actividad lanzada:
DataHolder.getInstance().retrieve(someId);
Puede o no tener que pasar la identificación del objeto usando los extras del intento. Todo depende de tu problema específico.
Persistir objetos en el disco
La idea es guardar los datos en el disco antes de iniciar la otra actividad.
Ventajas: puede iniciar la actividad desde otros lugares y, si los datos ya persisten, debería funcionar bien.
Desventajas es engorroso y lleva más tiempo implementarlo. Requiere más código y, por lo tanto, más posibilidades de introducir errores. También será mucho más lento.
Algunas de las formas de persistir objetos incluyen: