java - studio - Cómo pasar un objeto de una actividad a otra en Android
pasar una variable android studio (30)
Sé que la estática es mala, pero parece que nos vemos obligados a usarla aquí. El problema con parceables / seriazables es que las dos actividades tienen instancias duplicadas del mismo objeto = pérdida de memoria y CPU.
public class IntentMailBox { static Queue<Object> content = new LinkedList<Object>(); }
Actividad de llamada
IntentMailBox.content.add(level);
Intent intent = new Intent(LevelsActivity.this, LevelActivity.class);
startActivity(intent);
Actividad llamada (tenga en cuenta que onCreate () y onResume () pueden llamarse varias veces cuando el sistema destruye y recrea las actividades)
if (IntentMailBox.content.size()>0)
level = (Level) IntentMailBox.content.poll();
else
// Here you reload what you have saved in onPause()
Otra forma es declarar un campo estático de la clase que desea pasar en esa misma clase. Sólo servirá para este propósito. No olvide que puede ser nulo en onCreate, ya que su paquete de aplicaciones se ha descargado de la memoria por el sistema y se ha vuelto a cargar más tarde.
Teniendo en cuenta que aún debe manejar el ciclo de vida de la actividad, es posible que desee escribir todos los datos directamente a las preferencias compartidas, lo cual es doloroso con las estructuras de datos complejas.
Estoy intentando trabajar en el envío de 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;
}
}
Quiero enviar su objeto de una Activity a otra y luego mostrar los datos de la otra Activity .
¿Cómo puedo lograr eso?
Crea tu propia clase de 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());
En mi experiencia, hay tres soluciones principales, cada una con sus desventajas y ventajas:
Implementando Parcelable
Implementando Serializable
Usando una biblioteca de bus de eventos livianos de algún tipo (por ejemplo, EventBus de Greenrobot o Otto de Square)
Parcelable : rápido y estándar de Android, pero tiene un montón de código repetitivo y requiere cadenas codificadas para su referencia cuando se extraen valores de la intención (no se escriben con fuerza).
Serializable : cerca del cero, pero es el enfoque más lento y también requiere cadenas codificadas al extraer valores de la intención (no tipificados).
Bus de eventos : placa de calderas cero, enfoque más rápido y no requiere cadenas codificadas, pero requiere una dependencia adicional (aunque generalmente liviana, ~ 40 KB)
Publiqué una comparación muy detallada sobre estos tres enfoques, incluidos los puntos de referencia de eficiencia.
Hay un par de formas por las cuales puede acceder a variables u objetos en otras clases o Actividad.
A. Base de datos
B. Preferencias compartidas.
C. Serialización de objetos.
D. Una clase que puede contener datos comunes puede ser nombrada como Utilidades Comunes. Depende de ti.
E. Pasar datos a través de intenciones y la 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á incrustada en Android. SQLite admite características de base de datos relacionales estándar como sintaxis SQL, transacciones y declaraciones preparadas.
B. Preferencias compartidas
Supongamos que desea almacenar el nombre de usuario. Así que 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 dtatype deseado.
Como ir a 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 si lo puede usar para su propósito también.
Use Java Beans y almacene en él como uno de sus campos y use getters y setter para eso.
JavaBeans son clases de Java que tienen propiedades. Piense en las propiedades como variables de instancia privada. Dado que son privados, la única forma de acceder a ellos desde fuera de su clase es a través de métodos en la clase. Los métodos que cambian el valor de una propiedad se denominan métodos de establecimiento, y los métodos que recuperan el valor de una propiedad se denominan métodos de obtención.
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 use la serialización de objetos para serializar este objeto y en su otra clase, deserialice 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 que un objeto serializado se haya escrito en un archivo, puede leerse desde el archivo y deserializarse. 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 quieres tutorial para esto refiérase a:
Serialización en Java (blog post)
Obtener variable en otras clases (Desbordamiento de pila)
D. CommonUtilities
Puede crear una clase por sí mismo que puede contener datos comunes que necesita con frecuencia en su proyecto.
Muestra
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E. Pasando datos a través de intenciones.
Consulte el tutorial Android - Datos de parcelas para pasar entre Actividades usando clases Parcelable para esta opción de pasar datos.
He encontrado un método simple y elegante:
- No parcelable
- NO Serializable
- NO campo estático
- Autobús sin evento
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á que 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, Android Binder creará una referencia JNI global para el objeto java y liberará esta referencia JNI global cuando no haya ninguna referencia para este objeto java. binder guardará esta referencia JNI global en el objeto Binder.
* PRECAUCIÓN: este método SOLO funciona a menos que las dos actividades se ejecuten en el mismo proceso; de lo contrario, lance ClassCastException en (ObjectWrapperForBinder) getIntent (). GetExtras (). GetBinder ("object_value") *
Definición de la clase ObjectWrapperForBinder
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,
- use un método nativo personalizado para agregar su objeto java a la tabla de referencia global de JNI (a través de JNIEnv :: NewGlobalRef)
- coloque el entero devuelto (en realidad, JNIEnv :: NewGlobalRef return jobject, que es un puntero, podemos enviarlo a int de forma segura) a su Intención (a través de Intent :: putExtra)
- para el receptor
- obtener entero desde Intent (a través de Intent :: getInt)
- use un método nativo personalizado para restaurar su objeto java desde la tabla de referencia global de JNI (a través de JNIEnv :: NewLocalRef)
- eliminar elemento de la tabla de referencia global JNI (a través de JNIEnv :: DeleteGlobalRef),
Pero el Método 2 tiene un problema pequeño pero grave, si el receptor no puede restaurar el objeto java (por ejemplo, ocurre alguna excepción antes de restaurar el objeto java, o la actividad del receptor no existe en absoluto), entonces el objeto java se convertirá en un huérfano o pérdida de memoria, el Método 1 no tiene este problema, ya que la carpeta 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, usaremos el archivo de ayuda
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 manera, podemos pasar una interfaz entre dos actividades aunque se ejecuten en un proceso diferente y llamar al método de la interfaz de forma remota
Método 4
El método 3 no parece lo suficientemente simple porque debemos implementar una interfaz de ayuda. Si solo desea 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 asincrónica y secuencial.
En realidad, android.os.Messenger también es una interfaz de ayuda. Si tiene el código fuente de Android, puede 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 de singleton que contiene objetos temporales.
public class IntentHelper {
private static IntentHelper _instance;
private Hashtable<String, Object> _hash;
private IntentHelper() {
_hash = new Hashtable<String, Object>();
}
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 tus objetos en Intent, usa IntentHelper:
IntentHelper.addObjectForKey(obj, "key");
Dentro de su nueva actividad, puede obtener el objeto:
Object obj = (Object) IntentHelper.getObjectForKey("key");
Tenga en cuenta que una vez cargado, el objeto se elimina para evitar referencias innecesarias.
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 estamos obteniendo el objeto.
Intent i = getIntent();
Deneme dene = (Deneme)i.getSerializableExtra("sampleObject");
Eso es.
La mejor manera es tener una clase (llámela Control) en su aplicación que contenga una variable estática de tipo "Cliente" (en su caso). Inicializa la variable en tu Actividad A.
Por ejemplo:
Control.Customer = CustomerClass;
Luego vaya a la Actividad B y búsquelo en la clase Control. No olvide asignar un nulo después de usar la variable, de lo contrario se perderá la memoria.
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");
Por favor, asegúrese de que la clase del cliente implementa parcelable
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();
}
Si elige usar la forma que Samuh describe, recuerde que solo se pueden enviar valores primitivos. Es decir, valores que son parcables. Por lo tanto, si su objeto contiene objetos complejos, estos no seguirán. Por ejemplo, variables como Bitmap, HashMap, etc ... Estas son difíciles de pasar por la intención.
En general, le aconsejaría que envíe solo 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 un ContentProvider , SDCard , etc. También es posible usar una variable estática , pero esto puede llevar rápidamente a un código propenso a errores ...
Pero de nuevo, es solo mi opinión subjetiva.
También puede escribir los datos del objeto en cadenas e ints temporales, y pasarlos a la actividad. Por supuesto, de esa manera, obtiene los datos transportados, pero no el objeto en sí.
Pero si solo quiere mostrarlos y no usar el objeto en otro método o algo así, debería ser suficiente. Lo hice de la misma manera para mostrar los 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 temporales, pero de esta manera es más claro, en mi opinión. Además, puede establecer los valores temporales en nulos para que el GarbageCollector los limpie antes.
¡Buena suerte!
En una nota al margen: sobrescriba toString () en lugar de escribir su propio método de impresión.
Como se menciona en los comentarios a continuación, esta es la forma en que recupera sus datos en otra actividad:
String fName = getIntent().getExtras().getInt("fname");
Una opción podría ser permitir que su clase personalizada implemente la interfaz Serializable y luego puede pasar instancias de objetos en el intento 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 cualquier excepción de serialización. Por ejemplo:
class MainClass implements Serializable {
public MainClass() {}
public static class ChildClass implements Serializable {
public ChildClass() {}
}
}
Usa gson para convertir tu objeto a JSON y pasarlo a través de la intención. En la nueva actividad convertir el JSON a un objeto.
En tu build.gradle , agrega esto a tus 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 cadena json de nuevo al objeto original:
Gson gson = new Gson();
YourObject ob = gson.fromJson(getIntent().getStringExtra("myjson"), YourObject.class);
Para Kotlin es lo mismo
Pasar los datos
val gson = Gson()
val intent = Intent(this, YourActivity::class.java)
intent.putExtra("identifier", gson.toJson(your_object))
startActivity(intent)
Recibir los datos
val gson = Gson()
val yourObject = gson.fromJson<YourObject>(intent.getStringExtra("identifier"), YourObject::class.java)
Estoy usando parcelable 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<Channel> CREATOR = new Parcelable.Creator<Channel>() {
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 la actividad, úsalo así:
Bundle bundle = new Bundle();
bundle.putParcelableArrayList("channel",(ArrayList<Channel>) channels);
Intent intent = new Intent(ActivityA.this,ActivityB.class);
intent.putExtras(bundle);
startActivity(intent);
En ActivityB lo usamos así para obtener datos:
Bundle getBundle = this.getIntent().getExtras();
List<Channel> channelsList = getBundle.getParcelableArrayList("channel");
Comience otra actividad de esta actividad y pase parámetros a través de Bundle Object.
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);
Recuperar datos sobre otra actividad (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
Esto está bien para el tipo simple de tipo de datos. Pero si quieres pasar datos complejos entre la actividad. Necesitas serializarlo primero.
Aquí tenemos modelo de empleado
class Employee{
private String empId;
private int age;
print Double salary;
getters...
setters...
}
Puede usar Gson lib proporcionado por google para serializar los datos complejos como este
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<Employee>() {
}.getType();
Employee selectedEmp = gson.fromJson(empStr, type);
Crea dos métodos en tu clase personalizada como esta
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();
}
}
}
Ahora en tu remitente Actividad haz como esto
Qabir q= new Qabir(22,"KQ");
Intent in=new Intent(this,SubActivity.class);
in.putExtra("obj", q.toJSON());
startActivity( in);
Y en tu receptor Actividad.
Qabir q =new Qabir();
q.initilizeWithJSONString(getIntent().getStringExtra("obj"));
Hola a todos. Veo muchas buenas opciones, pero me preguntaba por qué no se ha utilizado Binding.
Pasar una referencia a un objeto simplemente me parece más eficiente que serializar y desestilizar objetos, pero no he hecho una inmersión profunda para ver si eso es lo que está sucediendo detrás de escena.
Crear un cuaderno es bastante simple ...
public class MyBinder extends Binder {
private Object myObject;
public MyBinder(Object object) {
myObject = object;
}
public Object getObject() {
return myObject;
}
}
Y crear lo parcelable para usarlo no es tan malo.
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<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel parcel) {
return new MyParcelable(parcel);
}
public MyParcelable[] newArray(int length) {
return new MyParcelable[length];
}
};
}
Esta lógica es realmente genial porque en realidad estás pasando una referencia de actividad a actividad.
¡Recomendaría comprobar si hay nulos y si la instancia de Binder es MyBinder!
y para implementar esto solo ...
Envíalo
Object myObject = "some object";
MyParcelable myParcelable = new MyParcelable();
myParcelable.setObject(myObject);
intent.putExtra("MyParcelable", myParcelable);
Recuperar
myParcelable = (MyParcelable) getIntent().getExtras().getParcelable("MyParcelable");
myObject = myParcelable.getObject();
Joder, alguien podría volverse loco y hacer de este tonto un verdadero genérico.
Pasa una actividad a otra:
startActivity(new Intent(getBaseContext(),GetActivity.class).putExtra("passingkey","passingvalue"));
Obtener valores:
String myvalue= getIntent().getExtras("passingkey");
Pasar objeto de una actividad a otra actividad.
(1) actividad de fuente
Intent ii = new Intent(examreport_select.this,
BarChartActivity.class);
ii.putExtra("IntentExamResultDetail",
(Serializable) your List<ArraList<String>> object here);
startActivity(ii);
(2) actividad de destino
List<ArrayList<String>> aa = (List<ArrayList<String>>) getIntent()
.getSerializableExtra("IntentExamResultDetail");
Podemos pasar el objeto de una actividad a otra actividad:
SupplierDetails poSuppliersDetails = new SupplierDetails();
En el interior poSuppliersDetailstenemos algunos valores. Ahora estoy enviando este objeto a la actividad de destino:
Intent iPODetails = new Intent(ActivityOne.this, ActivityTwo.class);
iPODetails.putExtra("poSuppliersDetails", poSuppliersDetails);
Cómo obtener esto en ACtivityTwo:
private SupplierDetails supplierDetails;
supplierDetails =(SupplierDetails) getIntent().getSerializableExtra("poSuppliersDetails");
Sí, usar un objeto estático es, con mucho, la forma más fácil de hacerlo con objetos personalizados no serializables.
Crea una clase como una clase de bean e implementa la Serializableinterfaz. Luego podemos pasarlo por el intentmétodo, por ejemplo:
intent.putExtra("class", BeanClass);
Luego obténgalo de la otra actividad, por ejemplo:
BeanClass cb = intent.getSerializableExtra("class");
Esta pregunta también se discute en otra pregunta de desbordamiento de pila. Por favor, eche un vistazo a una solución para pasar datos a través de la intención utilizando Serializable . El punto principal es sobre el uso de un Bundleobjeto que almacena los datos necesarios en el interior Intent.
Bundle bundle = new Bundle();
bundle.putSerializable(key1, value1);
bundle.putSerializable(key2, value2);
bundle.putSerializable(key3, value3);
intent.putExtras(bundle);
Para extraer valores:
Bundle bundle = new Bundle();
for (String key : bundle.keySet()) {
value = bundle.getSerializable(key));
}
La ventaja de Serializablees su simplicidad. Sin embargo, debe considerar el uso de un Parcelablemétodo si necesita transferir muchos datos, ya que Parcelableestá diseñado específicamente para Android y es más eficiente que Serializable. Puedes crear la Parcelableclase usando:
- una herramienta en línea - site
- un plugin para Android Studio - generador de código parcelable de Android
Las respuestas anteriores casi todas son correctas, pero para aquellos que no las entienden, Android tiene una potente Intención de clase con la ayuda que comparte datos no solo entre la actividad, sino también con otros componentes de Android (receptor Broadcasr, servicios para el contenido, siempre que usemos la clase ContetnResolver no Intención ). En tu actividad construyes intención.
Intent intent = new Intent(context,SomeActivity.class);
intent.putExtra("key",value);
startActivity(intent);
En tu actividad de receving tienes
public class SomeActivity extends AppCompactActivity {
public void onCreate(...){
...
SomeObject someObject = getIntent().getExtras().getParceable("key");
}
}
Tiene que implementar una interfaz que se pueda copiar o serializar en su objeto para poder compartir entre actividades. Es difícil implementar Parcealbe en lugar de una interfaz serializable en un objeto, por eso Android tiene un complemento especialmente para esto. Descárguelo y úselo.
Los objetos de actividad de Android pueden ser destruidos y reconstituidos. Entonces, necesitarás usar otro enfoque para mirarlos , ¡o cualquier objeto que creen ! - arriba. Es decir, podría pasar como referencia de clase estática pero luego el identificador de objeto (Java llama a estas "referencias", al igual que SmallTalk; pero no son referencias en el sentido de C o ensamblaje) posiblemente será inválido más adelante porque una "característica" de Android OE es cualquier actividad que puede ser aniquilada y reconstituida más tarde.
La pregunta original hizo "Cómo pasar un objeto de una actividad a otra en Android" y nadie ha respondido eso. Por supuesto, puede serializar (Serializable, Parcelable, a / desde JSON) y pasar una copia de los datos del objeto y se podría crear un nuevo objeto con los mismos datos; pero NO tendrá las mismas referencias / manijas. Además, muchos otros usuarios mencionados pueden almacenar la referencia en un almacén estático. Y eso funcionará a menos que Android decida destruir su actividad.
Por lo tanto, para resolver realmente la pregunta original, necesitaría una búsqueda estática y cada objeto actualizará su referencia cuando se vuelva a crear. Por ejemplo, cada actividad de Android volvería a aparecer si se llama a onCreate. También puede ver cómo algunas personas usan la lista de tareas para buscar una Actividad por nombre. (El sistema está destruyendo temporalmente esta instancia de la actividad para ahorrar espacio ... realizar Tareas, la lista de tareas es efectivamente una lista especializada de la instancia de objeto más reciente de cada Actividad).
Para referencia:
Detenido: "La actividad está completamente oculta por otra actividad (la actividad está ahora en el" fondo "). La actividad detenida también está viva (el objeto Actividad se conserva en la memoria , mantiene toda la información del estado y del miembro, pero adjunta al administrador de ventanas). Sin embargo, ya no es visible para el usuario y el sistema puede anularlo cuando se necesita memoria en otro lugar ".
onDestroy "el sistema está destruyendo temporalmente esta instancia de la actividad para ahorrar espacio".
Por lo tanto, el Bus de mensajes es una solución viable. Básicamente "hace puntos". En lugar de tratar de tener referencias a objetos; luego vuelve a diseñar su diseño para usar MessagePassing en lugar de SequentialCode. Exponencialmente más difícil de depurar; pero le permite ignorar este tipo de entendimientos de OperatingEnvironment. Efectivamente, cada acceso al método del objeto se invierte, por lo que la persona que llama publica un Mensaje y el propio objeto define un controlador para ese mensaje. Mucho más código, pero puede hacer que sea robusto con las restricciones de OE de Android.
Si todo lo que desea es la Actividad principal (algo típico en las aplicaciones de Android debido a que se necesita "Contexto" en todas partes), entonces puede hacer que cada Actividad se enumere como "superior" en el espacio global estático siempre que se llame onResume. Entonces su AlertDialog o lo que sea que necesite un contexto puede simplemente tomarlo desde allí. Además, es un poco extraño usar un global, pero puede simplificar pasar un contexto hacia arriba y hacia abajo en todas partes y, por supuesto, cuando se usa un MessageBus, entonces ES de todos modos global.
Puedes intentar usar esa clase. La limitación es que no se puede utilizar 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);
}
}
Siempre me había preguntado por qué esto no puede ser tan simple como llamar a un método de la otra actividad. Recientemente escribí una biblioteca de utilidades que lo hace casi tan simple como eso. Puede verlo aquí ( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher ).
GNLauncher hace que el envío de objetos / datos a una actividad desde otra actividad, etc., sea tan fácil como llamar una función en la actividad con los datos requeridos como parámetros. Introduce el tipo de seguridad y elimina todos los problemas de tener que serializar, adjuntar a la intención mediante el uso de claves de cadena y deshacer el mismo en el otro extremo.
Uso
Defina una interfaz con los métodos que desea llamar en la Actividad para iniciar.
public interface IPayload {
public void sayHello(String name, int age);
}
Implementar la interfaz anterior en la Actividad para iniciar. También notifique a GNLauncher cuando la actividad esté lista.
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);
}
}
En la otra actividad, obtenga un proxy para la actividad anterior y llame a cualquier método con los parámetros deseados.
public class Activity_2 extends Activity {
public void onClick(View v) {
((IPayload)GNLauncher.get().getProxy(this, IPayload.class, Activity_1.class)).sayHello(name, age);
}
}
Se iniciará la primera actividad y se recurrirá al método con los parámetros requeridos.
Prerrequisitos
Consulte https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites para obtener información sobre cómo agregar las dependencias.
Solía configurar el objeto con Pacelable o Serializable para transferir, pero cada vez que agrego otras variables al objeto (modelo), tengo que registrarlo todo. Es tan poco conveniente.
Es súper fácil transferir objetos entre actividades o fragmentos.
public class MyClass implements Serializable{
Here is your instance variable
}
Ahora quieres 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 .
- 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 agotador .
- El uso serializable está bien, pero no es eficiente en rendimiento en la plataforma Android.
- Parcelable está diseñado específicamente para Android y debes usarlo. Aquí hay un ejemplo simple: pasar objetos personalizados entre actividades de Android
Puede generar código Parcelable para su clase usando este site .