studio - pasar objetos entre actividades android
Crear una aplicación para Android
Archivo >> Nuevo >> Aplicación de Android
Ingrese el nombre del proyecto: android-pass-object-to-activity
Pakcage: com.hmkcode.android
Mantenga otras selecciones predeterminadas, vaya a Siguiente hasta que llegue a Finalizar
Antes de comenzar a crear la aplicación, necesitamos crear la clase POJO "Persona" que utilizaremos para enviar un objeto de una actividad a otra. Observe que la clase está implementando una interfaz serializable.
Persona.java
package com.hmkcode.android;
import java.io.Serializable;
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
// getters & setters....
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
Dos diseños para dos actividades
activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:id="@+id/tvName"
android:layout_width="100dp"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:gravity="center_horizontal"
android:text="Name" />
<EditText
android:id="@+id/etName"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:ems="10" >
<requestFocus />
</EditText>
</LinearLayout>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:id="@+id/tvAge"
android:layout_width="100dp"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:gravity="center_horizontal"
android:text="Age" />
<EditText
android:id="@+id/etAge"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:ems="10" />
</LinearLayout>
<Button
android:id="@+id/btnPassObject"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:text="Pass Object to Another Activity" />
</LinearLayout>
activity_another.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
>
<TextView
android:id="@+id/tvPerson"
android:layout_height="wrap_content"
android:layout_width="fill_parent"
android:layout_gravity="center"
android:gravity="center_horizontal"
/>
</LinearLayout>
Dos clases de actividades
1) ActivityMain.java
package com.hmkcode.android;
import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
public class MainActivity extends Activity implements OnClickListener {
Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnPassObject = (Button) findViewById(R.id.btnPassObject);
etName = (EditText) findViewById(R.id.etName);
etAge = (EditText) findViewById(R.id.etAge);
btnPassObject.setOnClickListener(this);
}
@Override
public void onClick(View view) {
// 1. create an intent pass class name or intnet action name
Intent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");
// 2. create person object
Person person = new Person();
person.setName(etName.getText().toString());
person.setAge(Integer.parseInt(etAge.getText().toString()));
// 3. put person in intent data
intent.putExtra("person", person);
// 4. start the activity
startActivity(intent);
}
}
2) AnotherActivity.java
package com.hmkcode.android;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;
public class AnotherActivity extends Activity {
TextView tvPerson;
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_another);
// 1. get passed intent
Intent intent = getIntent();
// 2. get person object from intent
Person person = (Person) intent.getSerializableExtra("person");
// 3. get reference to person textView
tvPerson = (TextView) findViewById(R.id.tvPerson);
// 4. display name & age on textView
tvPerson.setText(person.toString());
}
}
En tu primera actividad:
intent.putExtra("myTag", yourObject);
Y en tu segundo:
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
No olvides hacer tu objeto personalizado Serializable:
public class myCustomObject implements Serializable {
...
}
Existen varias formas mediante las cuales 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 puede denominarse como Utilidades comunes, depende de usted.
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.
Tutoriales - http://www.vogella.com/articles/AndroidSQLite/article.html
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 (), 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 la 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 el objeto Serialzation 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, se puede leer del archivo y deserializar, 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 un tutorial para esto consulta este enlace.
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
Obtener variable en otras clases
D. CommonUtilities
Puede crear una clase por su cuenta 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
Por favor, consulte este tutorial para esta opción de pasar datos.
Gracias por la ayuda parcelable pero encontré una solución opcional más
public class getsetclass implements Serializable {
private int dt = 10;
//pass any object, drwabale
public int getDt() {
return dt;
}
public void setDt(int dt) {
this.dt = dt;
}
}
En la actividad uno
getsetclass d = new getsetclass ();
d.setDt(50);
LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
obj.put("hashmapkey", d);
Intent inew = new Intent(SgParceLableSampelActivity.this,
ActivityNext.class);
Bundle b = new Bundle();
b.putSerializable("bundleobj", obj);
inew.putExtras(b);
startActivity(inew);
Obtener datos en la actividad 2
try { setContentView(R.layout.main);
Bundle bn = new Bundle();
bn = getIntent().getExtras();
HashMap<String, Object> getobj = new HashMap<String, Object>();
getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
getsetclass d = (getsetclass) getobj.get("hashmapkey");
} catch (Exception e) {
Log.e("Err", e.getMessage());
}
Implementar serializable en su clase.
public class Place implements Serializable{
private int id;
private String name;
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Entonces puedes pasar este objeto con intención.
Intent intent = new Intent(this, SecondAct.class);
intent.putExtra("PLACE", Place);
startActivity();
En la segunda actividad puedes obtener datos como este.
Place place= (Place) getIntent().getSerializableExtra("PLACE");
Pero cuando los datos se vuelven grandes, este método será lento.
Luché con el mismo problema. Lo resolví utilizando una clase estática, almacenando todos los datos que quiero en un HashMap. En la parte superior, uso una extensión de la clase de actividad estándar en la que he anulado los métodos onCreate un onDestroy para hacer el transporte de datos y el borrado de datos ocultos. Algunos ajustes ridículos deben cambiarse, por ejemplo, el manejo de la orientación.
Anotación: no proporcionar objetos generales para pasar a otra actividad es dolor en el culo. Es como dispararse en la rodilla y esperar ganar 100 metros. "Parcable" no es un sustituto suficiente. Me hace reír ... No quiero implementar esta interfaz en mi API sin tecnología, ya que menos quiero presentar una nueva Capa ... ¿Cómo podría ser que estemos en la programación móvil tan lejos de paradigma moderno ...
Otra forma de hacer esto es usar el objeto de la Application (android.app.Application). Usted define esto en su archivo AndroidManifest.xml como:
<application
android:name=".MyApplication"
...
Luego puede llamar a esto desde cualquier actividad y guardar el objeto en la clase de Application .
En la FirstActivity:
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
En la Segunda Actividad, haz:
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
Esto es útil si tiene objetos que tienen un alcance de nivel de aplicación, es decir, tienen que usarse en toda la aplicación. El método Parcelable aún es mejor si desea un control explícito sobre el alcance del objeto o si el alcance es limitado.
Esto evita el uso de Intents completo, sin embargo. No sé si te quedan bien. Otra forma en que utilicé esto es tener identificadores int de objetos enviados a través de intentos y recuperar objetos que tengo en Mapas en el objeto Application .
Para situaciones en las que sabe que pasará datos dentro de una aplicación, use "globales" (como Clases estáticas)
Esto es lo que Dianne Hackborn (hackbod, un ingeniero de software de Google para Android) dijo al respecto:
Para situaciones en las que sabe que las actividades se ejecutan en el mismo proceso, solo puede compartir datos a través de globales. Por ejemplo, podría tener un
HashMap<String, WeakReference<MyInterpreterState>>globalHashMap<String, WeakReference<MyInterpreterState>>y cuando cree un nuevo MyInterpreterState aparecerá un nombre único para él y lo pondrá en el mapa hash; para enviar ese estado a otra actividad, simplemente coloque el nombre único en el mapa hash y cuando se inicie la segunda actividad, puede recuperar MyInterpreterState del mapa hash con el nombre que recibe.
Puede utilizar Android BUNDLE para hacer esto.
Crea un paquete de tu clase como:
public Bundle toBundle() {
Bundle b = new Bundle();
b.putString("SomeKey", "SomeValue");
return b;
}
Luego pasa este paquete con INTENT. Ahora puedes recrear tu objeto de clase pasando un paquete como
public CustomClass(Context _context, Bundle b) {
context = _context;
classMember = b.getString("SomeKey");
}
Declara esto en tu clase personalizada y úsalo.
Puedes enviar objeto serializable a través de la intención.
// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);
//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");
And
Class ClassName implements Serializable {
}
Respuesta corta para necesidad rápida
1. Implementar su clase a Serializable.
Si tiene clases internas, ¡no olvide implementarlas también en Serializable!
public class SportsData implements Serializable
public class Sport implements Serializable
List<Sport> clickedObj;
2. Pon tu objeto en Intención
Intent intent = new Intent(SportsAct.this, SportSubAct.class);
intent.putExtra("sport", clickedObj);
startActivity(intent);
3. Y recibe tu objeto en la otra clase de actividad.
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
Sé que es tarde pero es muy simple. Todo lo que tiene que hacer es dejar que su clase implemente Serializable como
public class MyClass implements Serializable{
}
entonces puedes pasar a un intento como
Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);
Para conseguirlo simplemente llamas
MyClass objec=(MyClass)intent.getExtra("theString");
Si solo estás pasando objetos, Parcelable fue diseñado para esto. Requiere un poco más de esfuerzo que usar la serialización nativa de Java, pero es mucho más rápido (y quiero decir, mucho más rápido).
De los documentos, un ejemplo simple de cómo implementar es:
// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
private int mData;
/* everything below here is for implementing Parcelable */
// 99.9% of the time you can just ignore this
@Override
public int describeContents() {
return 0;
}
// write your object''s data to the passed-in Parcel
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
// this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
// example constructor that takes a Parcel and gives you an object populated with it''s values
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
Observe que en el caso de que tenga más de un campo para recuperar de una Parcela determinada, debe hacer esto en el mismo orden en que los colocó (es decir, en un enfoque FIFO).
Una vez que haya implementado sus objetos Parcelable , es solo cuestión de ponerlos en sus Intents con putExtra() :
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
Luego puedes sacarlos con getParcelableExtra() :
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
Si su Clase de Objetos implementa Parcelable y Serializable, entonces asegúrese de realizar una de las siguientes acciones:
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
Si su clase de objeto implementa Serializable , no necesita hacer nada más, puede pasar un objeto serializable.
eso es lo que yo uso
Su clase debe implementar Serializable o Parcelable.
public class MY_CLASS implements Serializable
Una vez hecho esto puedes enviar un objeto en putExtra
intent.putExtra("KEY", MY_CLASS_instance);
startActivity(intent);
Para obtener extras solo tienes que hacer
Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");
Si su clase implementa uso parcelable siguiente
MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");
Espero que ayude: D
Tendrá que serializar su objeto en algún tipo de representación de cadena. Una posible representación de cadena es JSON, y una de las formas más fáciles de serializar a / desde JSON en Android, si me preguntas, es a través de Google GSON .
En ese caso, simplemente coloca el valor de retorno de cadena de (new Gson()).toJson(myObject); y recupere el valor de la cadena y use fromJson para convertirlo de nuevo en su objeto.
Sin embargo, si su objeto no es muy complejo, podría no valer la pena la sobrecarga, y podría considerar pasar los valores separados del objeto en su lugar.
Utilizo Gson con su api tan potente y simple para enviar objetos entre actividades,
Ejemplo
// This is the object to be sent, can be any object
public class AndroidPacket {
public String CustomerName;
//constructor
public AndroidPacket(String cName){
CustomerName = cName;
}
// other fields ....
// You can add those functions as LiveTemplate !
public String toJson() {
Gson gson = new Gson();
return gson.toJson(this);
}
public static AndroidPacket fromJson(String json) {
Gson gson = new Gson();
return gson.fromJson(json, AndroidPacket.class);
}
}
2 funciones que se agregan a los objetos que desea enviar
Uso
Enviar objeto de A a B
// Convert the object to string using Gson
AndroidPacket androidPacket = new AndroidPacket("Ahmad");
String objAsJson = androidPacket.toJson();
Intent intent = new Intent(A.this, B.class);
intent.putExtra("my_obj", objAsJson);
startActivity(intent);
Recibir en B
@Override
protected void onCreate(Bundle savedInstanceState) {
Bundle bundle = getIntent().getExtras();
String objAsJson = bundle.getString("my_obj");
AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);
// Here you can use your Object
Log.d("Gson", androidPacket.CustomerName);
}
Lo uso casi en todos los proyectos que hago y no tengo problemas de rendimiento.
en tu modelo de clase (Objeto) implementa Serializable, por ejemplo:
public class MensajesProveedor implements Serializable {
private int idProveedor;
public MensajesProveedor() {
}
public int getIdProveedor() {
return idProveedor;
}
public void setIdProveedor(int idProveedor) {
this.idProveedor = idProveedor;
}
}
y tu primera actividad
MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
i.putExtra("mensajes",mp);
startActivity(i);
y tu segunda actividad (NewActivity)
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
¡¡buena suerte!!
la solución más fácil que encontré es ... crear una clase con miembros de datos estáticos con configuradores de obtención.
establecer a partir de una actividad y obtener de otra actividad ese objeto.
actividad A
mytestclass.staticfunctionSet("","",""..etc.);
actividad b
mytestclass obj= mytestclass.staticfunctionGet();
puede usar los métodos putExtra (Serializable ..) y getSerializableExtra () para pasar y recuperar objetos de su tipo de clase; tendrá que marcar su clase Serializable y asegurarse de que todas sus variables miembro también sean serializables ...
Iniciar otra actividad desde esta actividad. Pasar parámetros a través de Bundle Object.
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);
Recuperar en otra actividad (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
Esto está bien para el tipo de datos de tipo simple. Pero si desea pasar datos complejos entre la actividad, primero debe serializarlos.
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);
Lo más simple sería usar lo siguiente donde el elemento es una cadena:
intent.putextra("selected_item",item)
Para recibir:
String name = data.getStringExtra("selected_item");
Si tiene una clase singleton (servicio fx) que actúa como puerta de entrada a su capa de modelo de todos modos, puede resolverse teniendo una variable en esa clase con captadores y configuradores para ella.
En la Actividad 1:
Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);
En la Actividad 2:
private Service service;
private Order order;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_quality);
service = Service.getInstance();
order = service.getSavedOrder();
service.setSavedOrder(null) //If you don''t want to save it for the entire session of the app.
}
En servicio:
private static Service instance;
private Service()
{
//Constructor content
}
public static Service getInstance()
{
if(instance == null)
{
instance = new Service();
}
return instance;
}
private Order savedOrder;
public Order getSavedOrder()
{
return savedOrder;
}
public void setSavedOrder(Order order)
{
this.savedOrder = order;
}
Esta solución no requiere ninguna serialización u otro "empaquetado" del objeto en cuestión. Pero solo será beneficioso si está utilizando este tipo de arquitectura de todos modos.
Usando la biblioteca Gson de Google, puede pasar el objeto a otras actividades. De hecho, convertiremos el objeto en forma de cadena json y, después de pasar a otra actividad, volveremos a convertirlo en un objeto como este
Considera una clase de frijol como esta
public class Example {
private int id;
private String name;
public Example(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Necesitamos pasar el objeto de la clase Ejemplo.
Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);
Para leer necesitamos hacer la operación inversa en NextActivity
Example defObject=new Example(-1,null);
//default value to return when example is not available
String defValue= new Gson().toJson(defObject);
String jsonString=getIntent().getExtras().getString("example",defValue);
//passed example object
Example exampleObject=new Gson().fromJson(jsonString,Example .class);
Añadir esta dependencia en Gradle.
compile ''com.google.code.gson:gson:2.6.2''
Clase POJO "Publicar " (Tenga en cuenta que se implementa como serializable)
package com.example.booklib;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import android.graphics.Bitmap;
public class Post implements Serializable{
public String message;
public String bitmap;
List<Comment> commentList = new ArrayList<Comment>();
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getBitmap() {
return bitmap;
}
public void setBitmap(String bitmap) {
this.bitmap = bitmap;
}
public List<Comment> getCommentList() {
return commentList;
}
public void setCommentList(List<Comment> commentList) {
this.commentList = commentList;
}
}
Clase POJO "Comentario" (desde que es miembro de la clase Post, también se necesita para implementar el Serializable)
package com.example.booklib;
import java.io.Serializable;
public class Comment implements Serializable{
public String message;
public String fromName;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getFromName() {
return fromName;
}
public void setFromName(String fromName) {
this.fromName = fromName;
}
}
Luego, en su clase de actividad, puede hacer lo siguiente para pasar el objeto a otra actividad.
ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
Post item = (Post)parent.getItemAtPosition(position);
Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
intent.putExtra("post",item);
startActivity(intent);
}
});
En su clase de destinatario "CommentsActivity" puede obtener los datos de la siguiente manera
Post post =(Post)getIntent().getSerializableExtra("post");
De lejos, la manera más fácil de parcelar los objetos. Simplemente agregue una etiqueta de anotación sobre el objeto que desea hacer parcelable.
Un ejemplo de la biblioteca se encuentra debajo de https://github.com/johncarl81/parceler
@Parcel
public class Example {
String name;
int age;
public Example(){ /*Required empty bean constructor*/ }
public Example(int age, String name) {
this.age = age;
this.name = name;
}
public String getName() { return name; }
public int getAge() { return age; }
}
Primero implementa Parcelable en tu clase. Luego pasa un objeto como este.
SendActivity.java
ObjectA obj = new ObjectA();
// Set values etc.
Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);
startActivity(i);
ReceiveActivity.java
Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");
La cadena del paquete no es necesaria, solo la cadena debe ser la misma en ambas Actividades
Si no tiene mucha información sobre el uso de la función putExtra y solo desea iniciar otra actividad con objetos, puede consultar la biblioteca GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) que escribí en un intento Para hacer este proceso más sencillo.
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 todas las molestias de tener que serializar, adjuntar a la intención usando claves de cadena y deshacer la misma en el otro extremo.
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
public class SharedBooking implements Parcelable{
public int account_id;
public Double betrag;
public Double betrag_effected;
public int taxType;
public int tax;
public String postingText;
public SharedBooking() {
account_id = 0;
betrag = 0.0;
betrag_effected = 0.0;
taxType = 0;
tax = 0;
postingText = "";
}
public SharedBooking(Parcel in) {
account_id = in.readInt();
betrag = in.readDouble();
betrag_effected = in.readDouble();
taxType = in.readInt();
tax = in.readInt();
postingText = in.readString();
}
public int getAccount_id() {
return account_id;
}
public void setAccount_id(int account_id) {
this.account_id = account_id;
}
public Double getBetrag() {
return betrag;
}
public void setBetrag(Double betrag) {
this.betrag = betrag;
}
public Double getBetrag_effected() {
return betrag_effected;
}
public void setBetrag_effected(Double betrag_effected) {
this.betrag_effected = betrag_effected;
}
public int getTaxType() {
return taxType;
}
public void setTaxType(int taxType) {
this.taxType = taxType;
}
public int getTax() {
return tax;
}
public void setTax(int tax) {
this.tax = tax;
}
public String getPostingText() {
return postingText;
}
public void setPostingText(String postingText) {
this.postingText = postingText;
}
public int describeContents() {
// TODO Auto-generated method stub
return 0;
}
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(account_id);
dest.writeDouble(betrag);
dest.writeDouble(betrag_effected);
dest.writeInt(taxType);
dest.writeInt(tax);
dest.writeString(postingText);
}
public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
{
public SharedBooking createFromParcel(Parcel in)
{
return new SharedBooking(in);
}
public SharedBooking[] newArray(int size)
{
return new SharedBooking[size];
}
};
}
Pasando los datos:
Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);
Recuperando los datos:
Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");