Cómo pasar un objeto de una actividad a otra en Android

Estoy intentando trabajar enviando un objeto de mi clase de cliente desde una Activity y mostrarlo en otra Activity .

El código para la clase de cliente:

 public class Customer { private String firstName, lastName, Address; int Age; public Customer(String fname, String lname, int age, String address) { firstName = fname; lastName = lname; Age = age; Address = address; } public String printValues() { String data = null; data = "First Name :" + firstName + " Last Name :" + lastName + " Age : " + Age + " Address : " + Address; return data; } } 

Deseo enviar su objeto de una Activity a otra y luego mostrar los datos en la otra Activity .

¿Cómo puedo lograr eso?

Una opción podría ser permitir que su clase personalizada implemente la interfaz Serializable y luego puede pasar instancias de objeto en el bash extra usando la putExtra(Serializable..) del método Intent#putExtra() .

Pseudocódigo :

 //To pass: intent.putExtra("MyClass", obj); // To retrieve object in second Activity getIntent().getSerializableExtra("MyClass"); 

Nota: Asegúrese de que cada clase anidada de su clase personalizada principal haya implementado la interfaz Serializable para evitar excepciones de serialización. Por ejemplo:

 class MainClass implements Serializable { public MainClass() {} public static class ChildClass implements Serializable { public ChildClass() {} } } 

Implementa tu clase con Serializable. Supongamos que esta es su clase de entidad:

 import java.io.Serializable; @SuppressWarnings("serial") //With this annotation we are going to hide compiler warnings public class Deneme implements Serializable { public Deneme(double id, String name) { this.id = id; this.name = name; } public double getId() { return id; } public void setId(double id) { this.id = id; } public String getName() { return this.name; } public void setName(String name) { this.name = name; } private double id; private String name; } 

Estamos enviando el objeto llamado dene de la actividad X a la actividad Y. En algún lugar de la actividad X;

 Deneme dene = new Deneme(4,"Mustafa"); Intent i = new Intent(this, Y.class); i.putExtra("sampleObject", dene); startActivity(i); 

En la actividad Y, obtenemos el objeto.

 Intent i = getIntent(); Deneme dene = (Deneme)i.getSerializableExtra("sampleObject"); 

Eso es.

  • Usar variables estáticas globales no es una buena práctica de ingeniería de software .
  • Convertir los campos de un objeto en tipos de datos primitivos puede ser un trabajo agitado .
  • El uso de serializable está bien, pero no es eficiente en el rendimiento en la plataforma Android.
  • Parcelable está específicamente diseñado para Android y debe usarlo. Aquí hay un ejemplo simple: Pasar objetos personalizados entre actividades de Android

Puede generar código plotble para su clase utilizando este sitio .

Mientras llamas a una actividad

 Intent intent = new Intent(fromClass.this,toClass.class).putExtra("myCustomerObj",customerObj); 

En toClass.java recibe la actividad por

 Customer customerObjInToClass = getIntent().getExtras().getParcelable("myCustomerObj"); 

Asegúrese de que la clase de cliente implemente plotble

 public class Customer implements Parcelable { private String firstName, lastName, address; int age; /* all your getter and setter methods */ public Customer(Parcel in ) { readFromParcel( in ); } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public LeadData createFromParcel(Parcel in ) { return new Customer( in ); } public Customer[] newArray(int size) { return new Customer[size]; } }; @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(firstName); dest.writeString(lastName); dest.writeString(address); dest.writeInt(age); } private void readFromParcel(Parcel in ) { firstName = in .readString(); lastName = in .readString(); address = in .readString(); age = in .readInt(); } 

En mi experiencia, hay tres soluciones principales, cada una con sus desventajas y ventajas:

  1. Implementando Parcelable

  2. Implementando Serializable

  3. Uso de una biblioteca de autobuses de eventos livianos de algún tipo (por ejemplo, GreenBow’s EventBus o Square’s Otto)

Parcelable : rápido y estándar de Android, pero tiene un montón de código repetitivo y requiere cadenas codificadas para referencia cuando se extraen los valores del bash (no fuertemente tipificado).

Serializable – casi repetitivo, pero es el enfoque más lento y también requiere cadenas codificadas cuando extrae los valores del bash (no fuertemente tipado).

Bus de eventos – cero repetición, el enfoque más rápido, y no requiere cadenas codificadas, pero sí una dependencia adicional (aunque generalmente ligera, ~ 40 KB)

Publiqué una comparación muy detallada sobre estos tres enfoques, incluidos los puntos de referencia de eficiencia.

Usa gson para convertir tu objeto a JSON y pasarlo a través de la intención. En la nueva actividad convierte el JSON en un objeto.

En su build.gradle , agregue esto a sus dependencias

 implementation 'com.google.code.gson:gson:2.8.4' 

En tu Actividad, convierte el objeto a json-string:

 Gson gson = new Gson(); String myJson = gson.toJson(vp); intent.putExtra("myjson", myjson); 

En su Actividad de recepción, convierta la json-string de nuevo en el objeto original:

 Gson gson = new Gson(); YourObject ob = gson.fromJson(getIntent().getStringExtra("myjson"), YourObject.class); 

También puede escribir los datos del objeto en cadenas y datos temporales, y pasarlos a la actividad. Por supuesto, de esa manera, obtienes los datos transportados, pero no el objeto en sí.

Pero si solo quieres mostrarlos, y no usar el objeto en otro método o algo así, debería ser suficiente. Lo hice de la misma manera para simplemente mostrar datos de un objeto en otra actividad.

 String fName_temp = yourObject.getFname(); String lName_temp = yourObject.getLname(); String age_temp = yourObject.getAge(); String address_temp = yourObject.getAddress(); Intent i = new Intent(this, ToClass.class); i.putExtra("fname", fName_temp); i.putExtra("lname", lName_temp); i.putExtra("age", age_temp); i.putExtra("address", address_temp); startActivity(i); 

También podría pasarlos directamente en lugar de los temp ivars, pero de esta manera es más claro, en mi opinión. Además, puede configurar los tiempos para anular para que LimpiaCollector los limpie antes.

¡Buena suerte!

En una nota al margen: anule toString () en lugar de escribir su propio método de impresión.

Como se menciona en los comentarios a continuación, así es como recuperas tus datos en otra actividad:

 String fName = getIntent().getExtras().getInt("fname"); 

Encontré un método simple y elegante:

  • NO Parcelable
  • NO Serializable
  • NO campo estático
  • Sin bus de eventos

Método 1

Código para la primera actividad:

  final Object objSent = new Object(); final Bundle bundle = new Bundle(); bundle.putBinder("object_value", new ObjectWrapperForBinder(objSent)); startActivity(new Intent(this, SecondActivity.class).putExtras(bundle)); Log.d(TAG, "original object=" + objSent); 

Código para la segunda actividad:

  final Object objReceived = ((ObjectWrapperForBinder)getIntent().getExtras().getBinder("object_value")).getData(); Log.d(TAG, "received object=" + objReceived); 

encontrará objSent y objReceived tienen el mismo hashCode , por lo que son idénticos.

Pero ¿por qué podemos pasar un objeto Java de esta manera?

En realidad, la carpeta de Android creará referencia JNI global para el objeto java y lanzará esta referencia JNI global cuando no haya referencia para este objeto java. Binder guardará esta referencia JNI global en el objeto Binder.

* PRECAUCIÓN: este método SÓLO funciona a menos que las dos actividades se ejecuten en el mismo proceso, de lo contrario arrojar ClassCastException en (ObjectWrapperForBinder) getIntent (). GetExtras (). GetBinder (“object_value”) *

clase ObjectWrapperForBinder defination

 public class ObjectWrapperForBinder extends Binder { private final Object mData; public ObjectWrapperForBinder(Object data) { mData = data; } public Object getData() { return mData; } } 

Método 2

  • para el remitente,
    1. utilice un método nativo personalizado para agregar su objeto java a la tabla de referencia global JNI (a través de JNIEnv :: NewGlobalRef)
    2. pon el entero de retorno (en realidad, JNIEnv :: NewGlobalRef return jobject, que es un puntero, podemos convertirlo a int de forma segura) en tu Intent (a través de Intent :: putExtra)
  • para el receptor
    1. obtener un número entero de Intent (a través de Intent :: getInt)
    2. utiliza un método nativo personalizado para restaurar tu objeto java desde la tabla de referencia global JNI (a través de JNIEnv :: NewLocalRef)
    3. eliminar el elemento de la tabla de referencia global de JNI (a través de JNIEnv :: DeleteGlobalRef),

Pero el Método 2 tiene un pequeño pero serio problema, si el receptor no restaura el objeto java (por ejemplo, ocurre alguna excepción antes de restaurar el objeto java, o la actividad del receptor no existe), entonces el objeto Java se convertirá en un objeto huérfano o pérdida de memoria, el Método 1 no tiene este problema, porque el encuadernador de Android manejará esta excepción

Método 3

Para invocar el objeto java de forma remota, crearemos un contrato / interfaz de datos para describir el objeto java, utilizaremos el archivo aidl

IDataContract.aidl

 package com.example.objectwrapper; interface IDataContract { int func1(String arg1); int func2(String arg1); } 

Código para la primera actividad

  final IDataContract objSent = new IDataContract.Stub() { @Override public int func2(String arg1) throws RemoteException { // TODO Auto-generated method stub Log.d(TAG, "func2:: arg1=" + arg1); return 102; } @Override public int func1(String arg1) throws RemoteException { // TODO Auto-generated method stub Log.d(TAG, "func1:: arg1=" + arg1); return 101; } }; final Bundle bundle = new Bundle(); bundle.putBinder("object_value", objSent.asBinder()); startActivity(new Intent(this, SecondActivity.class).putExtras(bundle)); Log.d(TAG, "original object=" + objSent); 

Código para la segunda actividad:

cambie el atributo android: process en AndroidManifest.xml a un nombre de proceso no vacío para asegurarse de que la segunda actividad se ejecute en otro proceso

  final IDataContract objReceived = IDataContract.Stub.asInterface(getIntent().getExtras().getBinder("object_value")); try { Log.d(TAG, "received object=" + objReceived + ", func1()=" + objReceived.func1("test1") + ", func2()=" + objReceived.func2("test2")); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } 

De esta forma, podemos pasar una interfaz entre dos actividades aunque se ejecuten en un proceso diferente, y llamar el método de interfaz de forma remota

Método 4

el método 3 parece no ser lo suficientemente simple porque debemos implementar una interfaz de ayuda. Si solo quiere hacer una tarea simple y el valor de retorno del método no es necesario, podemos usar android.os.Messenger

Código para la primera actividad (remitente):

 public class MainActivity extends Activity { private static final String TAG = "MainActivity"; public static final int MSG_OP1 = 1; public static final int MSG_OP2 = 2; public static final String EXTRA_MESSENGER = "messenger"; private final Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub Log.e(TAG, "handleMessage:: msg=" + msg); switch (msg.what) { case MSG_OP1: break; case MSG_OP2: break; default: break; } super.handleMessage(msg); } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); startActivity(new Intent(this, SecondActivity.class).putExtra(EXTRA_MESSENGER, new Messenger(mHandler))); } } 

Código para la segunda actividad (receptor):

 public class SecondActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); final Messenger messenger = getIntent().getParcelableExtra(MainActivity.EXTRA_MESSENGER); try { messenger.send(Message.obtain(null, MainActivity.MSG_OP1, 101, 1001, "10001")); messenger.send(Message.obtain(null, MainActivity.MSG_OP2, 102, 1002, "10002")); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 

Todo el Messenger.send se ejecutará en un controlador de forma asíncrona y secuencial.

En realidad, android.os.Messenger también es una interfaz de ayuda, si tienes el código fuente de Android, puedes encontrar un archivo llamado IMessenger.aidl

 package android.os; import android.os.Message; /** @hide */ oneway interface IMessenger { void send(in Message msg); } 

Hice una clase de ayudante singleton que contiene objetos temporales.

 public class IntentHelper { private static IntentHelper _instance; private Hashtable _hash; private IntentHelper() { _hash = new Hashtable(); } private static IntentHelper getInstance() { if(_instance==null) { _instance = new IntentHelper(); } return _instance; } public static void addObjectForKey(Object object, String key) { getInstance()._hash.put(key, object); } public static Object getObjectForKey(String key) { IntentHelper helper = getInstance(); Object data = helper._hash.get(key); helper._hash.remove(key); helper = null; return data; } } 

En lugar de poner sus objetos dentro de Intent, use IntentHelper:

 IntentHelper.addObjectForKey(obj, "key"); 

Dentro de tu nueva actividad, puedes obtener el objeto:

 Object obj = (Object) IntentHelper.getObjectForKey("key"); 

Tenga en cuenta que una vez cargado, el objeto se elimina para evitar referencias innecesarias.

Hay un par de formas en las que puede acceder a variables u objetos en otras clases o actividades.

A. Base de datos

B. Preferencias compartidas.

C. Serialización de objetos.

D. Una clase que puede contener datos comunes se puede nombrar como Utilidades comunes. Depende de ti.

E. Pasar datos a través de Intentos e Interfaz Parcelable.

Depende de las necesidades de su proyecto.

A. Base de datos

SQLite es una base de datos de código abierto que está integrada en Android. SQLite admite características de bases de datos relacionales estándar como syntax SQL, transacciones y declaraciones preparadas.

Tutoriales

B. Preferencias compartidas

Supongamos que desea almacenar el nombre de usuario. Entonces ahora habrá dos cosas, un nombre de usuario clave , valor de valor.

Cómo almacenar

  // Create object of SharedPreferences. SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this); //Now get Editor SharedPreferences.Editor editor = sharedPref.edit(); //Put your value editor.putString("userName", "stackoverlow"); //Commits your edits editor.commit(); 

Usando putString (), putBoolean (), putInt (), putFloat () y putLong () puede guardar su tipo de dta deseado.

Cómo buscar

 SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this); String userName = sharedPref.getString("userName", "Not Available"); 

http://developer.android.com/reference/android/content/SharedPreferences.html

C. Serialización de objetos

La serlización de objetos se usa si queremos guardar un estado de objeto para enviarlo a través de una red o también puede usarlo para su propósito.

Use beans Java y almacénelo como uno de sus campos y use getters y setter para eso.

Los JavaBeans son clases de Java que tienen propiedades. Piense en las propiedades como variables de instancia privadas. Dado que son privados, la única forma en que se puede acceder desde fuera de su clase es a través de los métodos en la clase. Los métodos que cambian el valor de una propiedad se llaman métodos setter, y los métodos que recuperan el valor de una propiedad se llaman métodos getter.

 public class VariableStorage implements Serializable { private String inString; public String getInString() { return inString; } public void setInString(String inString) { this.inString = inString; } } 

Establezca la variable en su método de correo usando

 VariableStorage variableStorage = new VariableStorage(); variableStorage.setInString(inString); 

Luego usa la serialización de objetos para serializar este objeto y en tu otra clase deserializar este objeto.

En la serialización, un objeto se puede representar como una secuencia de bytes que incluye los datos del objeto, así como información sobre el tipo del objeto y los tipos de datos almacenados en el objeto.

Después de escribir un objeto serializado en un archivo, se puede leer del archivo y deserializarlo. Es decir, la información de tipo y los bytes que representan el objeto y sus datos se pueden usar para recrear el objeto en la memoria.

Si desea un tutorial para esto, consulte:

  • Serialización en Java (publicación de blog)

  • Obtener variable en otras clases (desbordamiento de stack)

D. CommonUtilities

Puede hacer una clase usted mismo que puede contener datos comunes que frecuentemente necesita en su proyecto.

Muestra

 public class CommonUtilities { public static String className = "CommonUtilities"; } 

E. Pasar datos a través de bashs

Consulte el tutorial Android: datos de plots para pasar entre las Actividades que usan clases Parcelable para esta opción de pasar datos.

La mejor manera es tener una clase (llámese Control) en su aplicación que contendrá una variable estática del tipo ‘Cliente’ (en su caso). Inicializa la variable en tu Actividad A.

Por ejemplo:

 Control.Customer = CustomerClass; 

Luego vaya a la Actividad B y descárguelo de la clase Control. No olvide asignar un valor nulo después de usar la variable; de ​​lo contrario, la memoria se desperdiciará.

 public class MyClass implements Serializable{ Here is your instance variable } 

Ahora quiere pasar el objeto de esta clase en startActivity. Simplemente usa esto:

 Bundle b = new Bundle(); b.putSerializable("name", myClassObject); intent.putExtras(b); 

Esto funciona aquí porque MyClass implementa Serializable .

Cree su propia clase Customer siguiente manera:

 import import java.io.Serializable; public class Customer implements Serializable { private String name; private String city; public Customer() { } public Customer(String name, String city) { this.name= name; this.city=city; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getCity() { return city; } public void setCity(String city) { this.city= city; } } 

En su método onCreate()

 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_top); Customer cust=new Customer(); cust.setName("abc"); cust.setCity("xyz"); Intent intent=new Intent(abc.this,xyz.class); intent.putExtra("bundle",cust); startActivity(intent); } 

En la clase de xyz activity necesitas usar el siguiente código:

 Intent intent=getIntent(); Customer cust=(Customer)intent.getSerializableExtra("bundle"); textViewName.setText(cust.getName()); textViewCity.setText(cust.getCity()); 

Si elige usar la forma que describe Samuh, recuerde que solo se pueden enviar valores primitivos. Es decir, valores que son parcables. Entonces, si su objeto contiene objetos complejos, estos no seguirán. Por ejemplo, variables como Bitmap, HashMap, etc. … Es difícil pasar por la intención.

En general, le aconsejaría que envíe únicamente tipos de datos primitivos como extras, como String, int, boolean, etc. En su caso sería: String fname , String lname , int age y String address .

Mi opinión: los objetos más complejos se comparten mejor implementando ContentProvider , SDCard , etc. También es posible usar una variable estática , pero esto puede conducir rápidamente a un código propenso a errores …

Pero de nuevo, es solo mi opinión subjetiva.

Estoy usando plotble para enviar datos de una actividad a otra actividad. Aquí está mi código que funciona bien en mi proyecto.

 public class Channel implements Serializable, Parcelable { /** */ private static final long serialVersionUID = 4861597073026532544L; private String cid; private String uniqueID; private String name; private String logo; private String thumb; /** * @return The cid */ public String getCid() { return cid; } /** * @param cid * The cid to set */ public void setCid(String cid) { this.cid = cid; } /** * @return The uniqueID */ public String getUniqueID() { return uniqueID; } /** * @param uniqueID * The uniqueID to set */ public void setUniqueID(String uniqueID) { this.uniqueID = uniqueID; } /** * @return The name */ public String getName() { return name; } /** * @param name * The name to set */ public void setName(String name) { this.name = name; } /** * @return the logo */ public String getLogo() { return logo; } /** * @param logo * The logo to set */ public void setLogo(String logo) { this.logo = logo; } /** * @return the thumb */ public String getThumb() { return thumb; } /** * @param thumb * The thumb to set */ public void setThumb(String thumb) { this.thumb = thumb; } public Channel(Parcel in) { super(); readFromParcel(in); } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public Channel createFromParcel(Parcel in) { return new Channel(in); } public Channel[] newArray(int size) { return new Channel[size]; } }; public void readFromParcel(Parcel in) { String[] result = new String[5]; in.readStringArray(result); this.cid = result[0]; this.uniqueID = result[1]; this.name = result[2]; this.logo = result[3]; this.thumb = result[4]; } public int describeContents() { return 0; } public void writeToParcel(Parcel dest, int flags) { dest.writeStringArray(new String[] { this.cid, this.uniqueID, this.name, this.logo, this.thumb}); } } 

En activityA usarlo así:

 Bundle bundle = new Bundle(); bundle.putParcelableArrayList("channel",(ArrayList) channels); Intent intent = new Intent(ActivityA.this,ActivityB.class); intent.putExtras(bundle); startActivity(intent); 

En ActivityB, úsalo así para obtener datos:

 Bundle getBundle = this.getIntent().getExtras(); List channelsList = getBundle.getParcelableArrayList("channel"); 

Puedes intentar usar esa clase. La limitación es que no se puede usar fuera de un proceso.

Una actividad:

  final Object obj1 = new Object(); final Intent in = new Intent(); in.putExtra(EXTRA_TEST, new Sharable(obj1)); 

Otra actividad:

 final Sharable s = in.getExtras().getParcelable(EXTRA_TEST); final Object obj2 = s.obj(); public final class Sharable implements Parcelable { private Object mObject; public static final Parcelable.Creator < Sharable > CREATOR = new Parcelable.Creator < Sharable > () { public Sharable createFromParcel(Parcel in ) { return new Sharable( in ); } @Override public Sharable[] newArray(int size) { return new Sharable[size]; } }; public Sharable(final Object obj) { mObject = obj; } public Sharable(Parcel in ) { readFromParcel( in ); } Object obj() { return mObject; } @Override public int describeContents() { return 0; } @Override public void writeToParcel(final Parcel out, int flags) { final long val = SystemClock.elapsedRealtime(); out.writeLong(val); put(val, mObject); } private void readFromParcel(final Parcel in ) { final long val = in .readLong(); mObject = get(val); } ///// private static final HashMap < Long, Object > sSharableMap = new HashMap < Long, Object > (3); synchronized private static void put(long key, final Object obj) { sSharableMap.put(key, obj); } synchronized private static Object get(long key) { return sSharableMap.remove(key); } } 

Crete a class like bean class and implement the Serializable interface. Then we can pass it through the intent method, for example:

 intent.putExtra("class", BeanClass); 

Then get it from the other activity, for example:

 BeanClass cb = intent.getSerializableExtra("class"); 

Create two methods in your custom Class like this

 public class Qabir { private int age; private String name; Qabir(){ } Qabir(int age,String name){ this.age=age; this.name=name; } // method for sending object public String toJSON(){ return "{age:" + age + ",name:\"" +name +"\"}"; } // method for get back original object public void initilizeWithJSONString(String jsonString){ JSONObject json; try { json =new JSONObject(jsonString ); age=json.getInt("age"); name=json.getString("name"); } catch (JSONException e) { e.printStackTrace(); } } } 

Now in your sender Activity do like this

 Qabir q= new Qabir(22,"KQ"); Intent in=new Intent(this,SubActivity.class); in.putExtra("obj", q.toJSON()); startActivity( in); 

And in your receiver Activity

 Qabir q =new Qabir(); q.initilizeWithJSONString(getIntent().getStringExtra("obj")); 

Start another activity from this activity and pass parameters via Bundle Object

 Intent intent = new Intent(getBaseContext(), YourActivity.class); intent.putExtra("USER_NAME", "xyz@gmail.com"); startActivity(intent); 

Retrive data on another activity (YourActivity)

 String s = getIntent().getStringExtra("USER_NAME"); 

This is ok for simple kind of data type. But if u want to pass complex data in between activity. U need to serialize it first.

Here we have Employee Model

 class Employee{ private String empId; private int age; print Double salary; getters... setters... } 

You can use Gson lib provided by google to serialize the complex data like this

 String strEmp = new Gson().toJson(emp); Intent intent = new Intent(getBaseContext(), YourActivity.class); intent.putExtra("EMP", strEmp); startActivity(intent); Bundle bundle = getIntent().getExtras(); String empStr = bundle.getString("EMP"); Gson gson = new Gson(); Type type = new TypeToken() { }.getType(); Employee selectedEmp = gson.fromJson(empStr, type); 

This question is also discussed in another Stack Overflow question. Please have a look at a solution to Passing data through intent using Serializable . The main point is about using Bundle object which stores the necessary data inside Intent .

  Bundle bundle = new Bundle(); bundle.putSerializable(key1, value1); bundle.putSerializable(key2, value2); bundle.putSerializable(key3, value3); intent.putExtras(bundle); 

To extract values:

  Bundle bundle = new Bundle(); for (String key : bundle.keySet()) { value = bundle.getSerializable(key)); } 

Advantage of Serializable is its simplicity. However, you should consider using Parcelable method if you need many data to be transferred, because Parcelable is specifically designed for Android and it is more efficient than Serializable . You can create Parcelable class using:

  1. an online tool – plotbler
  2. a plugin for Android Studio – Android Parcelable code generator

Yeah, using a static object is by far the easiest way of doing this with custom non-serialisable objects.

Android Activity objects can be destroyed and reconstituted. So, you will need to use another approach to look them – or any object they create !!! – up. That is, you could pass as static class reference but then the object handle (Java calls these “references”, as does SmallTalk; but they are not references in the sense of C or assembly) will be possibly invalid later because a “feature” of Android OE is any Activity can be annihilated and reconstituted later.

The original question asked “How to pass object from one activity to another in Android” and nobody has answered that. For sure, you can serialized (Serializable, Parcelable, to/from JSON) and pass a copy of the object’s data and a new object having the same data could be created; but it will NOT have the same references/handles. Also, many others mentioned you can store the reference in a static store. And that will work unless Android decides to onDestroy your Activity.

So, to really solve the original question you would need a static lookup plus each object will update its reference when/if it is recreated. Eg each Android Activity would relist itself if its onCreate is called. You can also see how some people use the task list to search out an Activity by name. (system is temporarily destroying this instance of the activity to save space..getRunningTasks, the task list is effectively a specialized listing of the most recent object instance of each Activity).

Para referencia:

Stopped: “The activity is completely obscured by another activity (the activity is now in the “background”). A stopped activity is also still alive (the Activity object is retained in memory , it maintains all state and member information, but is not attached to the window manager). However, it is no longer visible to the user and it can be killed by the system when memory is needed elsewhere.”

onDestroy “system is temporarily destroying this instance of the activity to save space.”

So, the Message Bus is a workable solution. It basically “punts”. Rather than try to have references to objects; then you re-architect your design to use MessagePassing instead of SequentialCode. Exponentially harder to debug; but it lets you ignore these sort of OperatingEnvironment understandings. Effectively, each object method access is inverted so the caller posts a Message and the object itself defines a handler for that message. Lots more code but can make it robust with the Android OE restrictions.

If all you want is the top Activity (typical thing in Android apps due to “Context” being needed everywhere), then you can just have each Activity lists itself as “top” in the static global space whenever its onResume is called. Then your AlertDialog or whatever which needs a context can just grab it from there. Also, its a bit yucky to use a global but can simplifying passing a Context up and down everywhere and, for sure, when you use a MessageBus then IT IS global anyways.

  1. I know that static is bad, but it seems that we’re forced to use it here. The problem with parceables/seriazables is that the two activities have duplicate instances of the same object = waste of memory and CPU.

     public class IntentMailBox { static Queue content = new LinkedList(); } 

Calling activity

 IntentMailBox.content.add(level); Intent intent = new Intent(LevelsActivity.this, LevelActivity.class); startActivity(intent); 

Called activity (note that onCreate() and onResume() may be called multiple times when the system destroys and recreates activities)

 if (IntentMailBox.content.size()>0) level = (Level) IntentMailBox.content.poll(); else // Here you reload what you have saved in onPause() 
  1. Another way is to declare a static field of the class that you want to pass in that very class. It will serve only for this purpose. Don’t forget that it can be null in onCreate, because your app package has been unloaded from memory by system and reloaded later.

  2. Bearing in mind that you still need to handle activity lifecycle, you may want to write all the data straight to shared preferences, painful with complex data structures as it is.

Above answers almost all correct but for those who doesn’t undestand those answers Android has powerfull class Intent with help of it you share data between not only activity but another components of Android (broadcasr receiver, servises for content provide we use ContetnResolver class no Intent). In your activity you build intent

 Intent intent = new Intent(context,SomeActivity.class); intent.putExtra("key",value); startActivity(intent); 

In your receving activity you have

 public class SomeActivity extends AppCompactActivity { public void onCreate(...){ ... SomeObject someObject = getIntent().getExtras().getParceable("key"); } } 

You have to implement Parceable or Serializable interface on your object in order to share between activities. It is hard to implement Parcealbe rather than Serializable interface on object that’s why android has plugin especially for this.Download it and use it

I had always wondered why this can’t be as simple as calling into a method of the other activity. I recently wrote a utility library that makes it almost as simple as that. You can check it out here( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher ).

GNLauncher makes sending objects/data to an Activity from another Activity etc as easy as calling a function in tha Activity with the required data as parameters. It introduces type safety and removes all the hastles of having to serialize, attaching to the intent using string keys and undoing the same at the other end.

Uso

Define an interface with the methods you want to call on the Activity to launch.

 public interface IPayload { public void sayHello(String name, int age); } 

Implement the above interface on the Activity to launch into. Also notify GNLauncher when the activity is ready.

 public class Activity_1 extends Activity implements IPayload { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //Notify GNLauncher when the Activity is ready. GNLauncher.get().ping(this); } @Override public void sayHello(String name, int age) { Log.d("gnlib_test", "Hello " + name + "! \nYour age is: " + age); } } 

In the other Activity, get a proxy to the above Activity and call any method with the desired parameters.

 public class Activity_2 extends Activity { public void onClick(View v) { ((IPayload)GNLauncher.get().getProxy(this, IPayload.class, Activity_1.class)).sayHello(name, age); } } 

The first activity will be launched and the method called into with the required parameters.

Requisitos previos

Please refer to https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites for information on how to add the dependencies.

Pass object from one activity to another activity.

(1) source activity

 Intent ii = new Intent(examreport_select.this, BarChartActivity.class); ii.putExtra("IntentExamResultDetail", (Serializable) your List> object here); startActivity(ii); 

(2) destination acitivity

 List> aa = (List>) getIntent() .getSerializableExtra("IntentExamResultDetail"); 

I used to set object with Pacelable or Serializable to transfer, but whenever I add other variables to object(model), I have to register it all. It’s so nconvenient.

It’s super easy to transfer object between activities or fragments.

Android DataCache

We can pass the object from one activity to another activity:

 SupplierDetails poSuppliersDetails = new SupplierDetails(); 

Inside poSuppliersDetails we have some values. Now I am sending this object to target activity:

 Intent iPODetails = new Intent(ActivityOne.this, ActivityTwo.class); iPODetails.putExtra("poSuppliersDetails", poSuppliersDetails); 

How to get this in ACtivityTwo:

 private SupplierDetails supplierDetails; supplierDetails =(SupplierDetails) getIntent().getSerializableExtra("poSuppliersDetails"); 

Pass one activity to another:

 startActivity(new Intent(getBaseContext(),GetActivity.class).putExtra("passingkey","passingvalue")); 

Get values:

 String myvalue= getIntent().getExtras("passingkey"); 

Hello all I see a lot of good options but I was wondering why Binding hasn’t been used?

Passing a reference to an object just seems more efficient to me than serializing and desterilizing objects, but I have not done a deep dive to see if that is what is going on behind the scenes.

Creating a Binder is simple enough…

 public class MyBinder extends Binder { private Object myObject; public MyBinder(Object object) { myObject = object; } public Object getObject() { return myObject; } } 

And creating the plotble to use it isn’t that bad ether.

 public class MyParcelable implements Parcelable { private Object myObject; public MyParcelable() { } public MyParcelable(Parcel parcel) { myObject = ((MyBinder)parcel.readStrongBinder()).getObject(); } public void setObject(Object object) { myObject = object; } public Object getObject() { return myObject; } public void writeToParcel(Parcel parcel, int flags) { parcel.writeStrongBinder(new MyBinder(myObject)); } public int describeContents() { return myObject == null ? 0 : 1; } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public MyParcelable createFromParcel(Parcel parcel) { return new MyParcelable(parcel); } public MyParcelable[] newArray(int length) { return new MyParcelable[length]; } }; } 

This logic is really cool because you are actually passing a reference from activity to activity.

I would advise checking for nulls and if the instanceof Binder is MyBinder!

and to implement this you just…

Send it off

 Object myObject = "some object"; MyParcelable myParcelable = new MyParcelable(); myParcelable.setObject(myObject); intent.putExtra("MyParcelable", myParcelable); 

Get it back

 myParcelable = (MyParcelable) getIntent().getExtras().getParcelable("MyParcelable"); myObject = myParcelable.getObject(); 

Heck someone could get all crazy and make this sucker a true generic.