¿Cuál es la mejor manera de compartir datos entre actividades?

Aquí una recopilación de las formas más comunes de lograrlo :

• Enviar datos dentro de la intención
• Campos estáticos
• HashMap deWeakReferences
• Objetos persistentes (sqlite, preferencias para compartir, archivos, etc.)

TL;DR : hay dos formas de compartir datos: pasar datos en los extras de la intención o guardarlos en otro lugar. Si los datos son primitivos, cadenas u objetos definidos por el usuario: envíelos como parte de los extras de intención (los objetos definidos por el usuario deben implementar 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 intents

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);

Sobre la segunda actividad:

Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");

Utilice este método si está pasando datos primitivos o cadenas . También puedes pasar objetos que implemente Serializable.

Aunque es tentador, deberías pensarlo dos veces antes de usarlo Serializable: es propenso a errores y terriblemente lento. Entonces, en general: manténgase alejadoSerializable si es posible. Si desea pasar objetos complejos definidos por el usuario, eche un vistazo a la Parcelableinterfaz . Es más difícil de implementar, pero tiene ganancias de velocidad considerables en comparación con Serializable.

Compartir 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 salir de ella), Android puede decidir cerrar 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 se cerrara la aplicación. En estos casos, los datos almacenados en un singleton (ya sea el suyo o el suyo Application) desaparecerán y podrían suceder cosas malas. Para evitar tales casos, puede conservar los objetos en el disco o verificar los datos antes de usarlos para asegurarse de que sean válidos.

Utilice una clase singleton

Tener una clase para contener 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

El singleton de la aplicación es una instancia android.app.Applicationque 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 iniciar la actividad:

MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);

Luego, de la actividad lanzada:

MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();

Campos estáticos

La idea es básicamente la misma que la del singleton, pero en este caso proporcionas 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();

HashMap deWeakReferences

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 iniciar la actividad:

DataHolder.getInstance().save(someId, someObject);

De la actividad lanzada:

DataHolder.getInstance().retrieve(someId);

Es posible que tengas que pasar o no la identificación del objeto utilizando los extras de la intención. 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: puedes 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 tanto, más posibilidades de introducir errores. También será mucho más lento.

Algunas de las formas de conservar objetos incluyen:

• Guárdalos en las preferencias compartidas.
• Guárdalos en una base de datos sqlite
• Guárdalos en un archivo (yo evitaría este)

Feb 02 '2011 18:02 Cristian