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

putextra android para que sirve

Question

Tengo una actividad que es la actividad principal utilizada en toda la aplicación y tiene una serie de variables. Tengo otras dos actividades en las que me gustaría poder usar los datos de la primera actividad. Ahora sé que puedo hacer algo como esto:

GlobalState gs = (GlobalState) getApplication();
String s = gs.getTestMe();

Sin embargo, quiero compartir muchas variables y algunas pueden ser bastante grandes, por lo que no quiero crear copias de ellas como la anterior.

¿Hay una manera de obtener y cambiar directamente las variables sin usar los métodos de obtener y establecer? Recuerdo haber leído un artículo en el sitio de desarrollo de Google diciendo que no se recomienda para el rendimiento en Android.

Answer 1

"Sin embargo, quiero compartir muchas variables y algunas pueden ser bastante grandes, por lo que no quiero crear copias de ellas como la anterior".

Eso no hace una copia (especialmente con String , pero incluso los objetos son pasados ​​por el valor de la referencia, no el objeto en sí, y los objetos de este tipo son adecuados para usar, posiblemente mejor usar que otros medios porque son comunes y comunes. bien entendido). Los "mitos de rendimiento" más antiguos, como no usar captadores y definidores, todavía tienen algún valor, pero también se han actualizado en los documentos .

Pero si no desea hacerlo, también puede hacer públicas las variables o protegidas en GlobalState y acceder a ellas directamente. Y, puede hacer un singleton estático como el objeto de la aplicación JavaDoc indica :

Normalmente no hay necesidad de subclase de aplicación. En la mayoría de las situaciones, los singletons estáticos pueden proporcionar la misma funcionalidad de una manera más modular. Si su singleton necesita un contexto global (por ejemplo, para registrar receptores de difusión), a la función para recuperarlo se le puede dar un Contexto que utiliza internamente Context.getApplicationContext () cuando se construye por primera vez el singleton.

Usar los datos de Intención , como lo señalan otras respuestas aquí, es otra forma de pasar datos, pero generalmente se usa para datos más pequeños y tipos simples. Puede pasar datos más grandes / más complejos, pero es más complicado que solo usar una única estática. Sin embargo, el objeto de la aplicación sigue siendo mi favorito personal para compartir datos no persistentes más grandes / más complejos entre los componentes de la aplicación de Android (porque tiene un ciclo de vida bien definido en una aplicación de Android).

Además, como han señalado otros, si los datos se vuelven muy complejos y necesitan ser persistentes , también puede usar SQLite o el sistema de archivos.

Answer 2

Aquí una recopilación de las formas más comunes para lograr esto :

• Enviar datos dentro de la intención
• Campos estáticos
• HashMap of WeakReferences
• Objetos persistentes (sqlite, compartir preferencias, archivos, 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 los extras del intento (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 intenciones

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");

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

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

Comparte datos sin persistir en el disco

Es posible compartir datos entre actividades guardándolas 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 anular 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 eliminara la aplicación. En estos casos, los datos almacenados en un singleton (ya sea el suyo o la Application ) se habrán ido y podrían ocurrir cosas malas. Para evitar tales casos, puede persistir los objetos en el disco o verificar los datos antes de usarlos para asegurarse de que sean válidos.

Usa una clase de singleton

Tener una clase para mantener 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();

Usa la aplicación singleton

La aplicación singleton es una instancia de android.app.Application que se crea cuando se inicia la aplicación. Puede proporcionar uno personalizado extendiendo la 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 String setData(String data) {DataHolder.data = data;}
}

De la actividad lanzada:

String data = DataHolder.getData();

HashMap of WeakReferences

La misma idea, pero permitiendo que el recolector de basura elimine objetos no referenciados (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 su problema específico.

Persistir objetos en 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 están almacenados, 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:

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

Answer 3

Bueno, tengo algunas ideas, pero no sé si son lo que estás buscando.

Puede usar un servicio que contenga todos los datos y luego vincular sus actividades al servicio para la recuperación de datos.

O puede empaquetar sus datos en un número serializable o parcelable y adjuntarlos a un paquete y pasar el paquete entre las actividades.

Es posible que este no sea en absoluto lo que está buscando, pero también puede intentar usar un SharedPreferences o una preferencia en general.

De cualquier manera déjame saber lo que decidas.

Answer 4

Compartir datos entre actividades, por ejemplo, pasar un correo electrónico después de iniciar sesión

"correo electrónico" es el nombre que se puede usar para hacer referencia al valor de la actividad que se solicita

1 código en la página de inicio de sesión

Intent openLoginActivity = new Intent(getBaseContext(), Home.class);
    openLoginActivity.putExtra("email", getEmail);

2 codigos en la pagina de inicio

Bundle extras = getIntent().getExtras();
    accountEmail = extras.getString("email");

Answer 5

Hay una nueva y mejor manera de compartir datos entre actividades, y es LiveData . Note en particular esta cita de la página del desarrollador de Android:

El hecho de que los objetos LiveData sean conscientes del ciclo de vida significa que puede compartirlos entre múltiples actividades, fragmentos y servicios. Para mantener el ejemplo simple, puede implementar la clase LiveData como un singleton

La implicación de esto es enorme: cualquier dato de modelo se puede compartir en una clase de singleton común dentro de un contenedor de LiveData . Se puede inyectar desde las actividades en su ViewModel respectivo por razones de comprobabilidad. Y ya no necesita preocuparse por las referencias débiles para evitar pérdidas de memoria.

Answer 6

Haz lo que Google te ordena hacer! Aquí: http://developer.android.com/resources/faq/framework.html#3

• Tipos de datos primitivos
• Objetos no persistentes
• Clase Singleton - mi favorita: D
• Un campo / método estático público
• Un HashMap de WeakReferences a objetos
• Objetos persistentes (Preferencias de aplicación, Archivos, Proveedores de contenido, Base de datos SQLite)

Answer 7

Lo que puedes usar:

1. pasando datos entre actividades (como dijo Cristian)
2. usar una clase con muchas variables estáticas (para que pueda llamarlas sin una instancia de la clase y sin usar getter / setter)
3. Utilizando una base de datos
4. Preferencias compartidas

Lo que elijas depende de tus necesidades. Probablemente usarás más de una manera cuando tengas "mucho"

Answer 8

Podría extender la clase de Application y etiquetar en cualquier objeto que desee allí, entonces estarán disponibles en cualquier lugar de su aplicación.

Answer 9

Si su intención es llamar a otras Actividades de la Actividad actual, debe usar Intents . Su enfoque podría ser menos en la persistencia de datos que en compartirlos según sea necesario.

Sin embargo, si realmente necesita conservar estos valores, podría conservarlos en algún tipo de archivo de texto estructurado o base de datos en el almacenamiento local. Un archivo de propiedades, un archivo XML o un archivo JSON podría almacenar sus datos y analizarlos fácilmente durante la creación de la actividad. No olvide también que tiene SQLite en todos los dispositivos Android, por lo que podría almacenarlos en una tabla de base de datos. También puede usar un Mapa para almacenar pares clave-valor y serializar el mapa en el almacenamiento local, pero esto puede ser demasiado engorroso para ser útil para estructuras de datos simples.

Answer 10

Suponiendo que está llamando a la actividad dos de la actividad uno usando una intención.
Puede pasar los datos con el intent.putExtra (),

Toma esto para tu referencia. Enviando matrices con Intent.putExtra

Espero que sea lo que quieres.

Answer 11

Todas las respuestas mencionadas anteriormente son geniales ... Solo estoy agregando una que nadie había mencionado aún sobre la persistencia de datos a través de actividades y es usar la base de datos integrada de SQLite para Android para conservar datos relevantes ... De hecho, puede colocar su databaseHelper en el estado de la aplicación y llámelo según sea necesario a través de los activados. O simplemente cree una clase auxiliar y realice las llamadas a la base de datos cuando sea necesario ... Simplemente agregue otra capa para que la tenga en cuenta ... Pero todas las demás respuestas serían suficientes como tambien .. realmente solo preferencia

Answer 12

Usar el mapa de hash del enfoque de referencia débil, descrito anteriormente, y en http://developer.android.com/guide/faq/framework.html parece problemático. ¿Cómo se reclaman las entradas completas, no solo el valor del mapa? ¿En qué ámbito lo asignas? Dado que el marco controla el ciclo de vida de la Actividad, tener una de las Actividades participantes es un riesgo de error de tiempo de ejecución cuando el propietario se destruye antes que sus clientes. Si la Aplicación lo posee, alguna Actividad debe eliminar explícitamente la entrada para evitar que el mapa hash retenga las entradas con una clave válida y una referencia débil recopilada potencialmente empaquetada. Además, ¿qué debe hacer un cliente cuando el valor devuelto para una clave es nulo?

Me parece que una WeakHashMap propiedad de la aplicación o dentro de un singleton es una mejor opción. Se accede a un valor en el mapa a través de un objeto clave, y cuando no existen referencias sólidas a la clave (es decir, todas las Actividades se realizan con la clave y a qué se asigna), GC puede reclamar la entrada del mapa.

Answer 13

Y si quieres trabajar con un objeto de datos, estos dos implementos son muy importantes:

Serializable vs Parcelable

• Serializable es una interfaz de marcador, lo que implica que el usuario no puede calcular los datos de acuerdo con sus requisitos. Entonces, cuando el objeto se implemente, Serializable Java lo serializará automáticamente.
• Parcelable es el propio protocolo de serialización de Android. En Parcelable, los desarrolladores escriben código personalizado para calcular y desmarcar. Por lo tanto, crea menos objetos de basura en comparación con la serialización.
• El rendimiento de Parcelable es muy alto en comparación con Serializable debido a su implementación personalizada. Se recomienda encarecidamente utilizar la implantación de Parcelable al serializar objetos en Android.

public class User implements Parcelable

ver más here

Answer 14

Hay varias formas de compartir datos entre actividades.

1: Pasar datos entre actividades utilizando Intent

Intent intent=new Intent(this, desirableActivity.class);
intent.putExtra("KEY", "Value");
startActivity(intent)

2: usando una palabra clave estática, defina la variable como estática pública y use en cualquier lugar del proyecto

      public static int sInitialValue=0;

usar en cualquier parte del proyecto usando classname.variableName;

3: Usando la base de datos

pero su proceso un poco largo, tiene que usar la consulta para insertar datos y iterar datos usando el cursor cuando sea necesario. Pero no hay posibilidad de perder datos sin limpiar el caché.

4: Uso de preferencias compartidas

mucho más fácil que la base de datos. pero hay alguna limitación que no puede guardar los objetos ArrayList, List y custome.

5: Cree el configurador de captadores en la clase de Aplicación y acceda a cualquier lugar del proyecto.

      private String data;
      public String getData() {
          return data;
      }

      public void setData(String data) {
          this.data = data;
      }

Aquí configurar y obtener de las actividades.

         ((YourApplicationClass)getApplicationContext()).setData("abc"); 

         String data=((YourApplicationClass)getApplicationContext()).getData();