Necesito pasar una referencia a la clase que realiza la mayor parte de mi procesamiento a través de un paquete.

El problema es que no tiene nada que ver con intenciones o contextos y tiene una gran cantidad de objetos no primitivos. ¿Cómo empaqueto la clase en un parcelable / serializable y la paso a un startActivityForResult?

Averiguar qué camino tomar requiere responder no solo a la pregunta clave de CommonsWare de "por qué", sino también a la pregunta de "¿a qué?" lo estás pasando.

La realidad es que lo único que puede pasar por paquetes son datos simples; todo lo demás se basa en interpretaciones de lo que significan o apuntan esos datos. No puede pasar literalmente un objeto, pero lo que puede hacer es una de tres cosas:

1) Puede dividir el objeto en sus datos constitutivos, y si lo que está en el otro extremo tiene conocimiento del mismo tipo de objeto, puede ensamblar un clon a partir de los datos serializados. Así es como la mayoría de los tipos comunes pasan a través de paquetes.

2) Puede pasar un mango opaco. Si lo pasa dentro del mismo contexto (aunque uno podría preguntarse por qué molestarse), ese será un identificador que puede invocar o desreferenciar. Pero si lo pasa a través de Binder a un contexto diferente, su valor literal será un número arbitrario (de hecho, estos números arbitrarios cuentan secuencialmente desde el inicio). No puede hacer nada más que realizar un seguimiento de él, hasta que lo devuelva al contexto original, lo que hará que Binder lo transforme de nuevo en el identificador original, haciéndolo útil nuevamente.

3) Puede pasar un identificador mágico, como un descriptor de archivo o una referencia a ciertos objetos de sistema operativo / plataforma, y ​​si establece las banderas correctas, Binder creará un clon apuntando al mismo recurso para el destinatario, que en realidad se puede usar en el otro extremo. Pero esto solo funciona para muy pocos tipos de objetos.

Lo más probable es que esté pasando su clase solo para que el otro extremo pueda realizar un seguimiento de ella y devolvérsela más tarde, o la está pasando a un contexto donde se puede crear un clon a partir de datos de constituyentes serializados ... o bien está tratando de hacer algo que simplemente no va a funcionar y necesita repensar todo el enfoque.

También puede usar Gson para convertir un objeto en un JSONObject y pasarlo a un paquete. Para mí fue la forma más elegante que encontré de hacer esto. No he probado cómo afecta al rendimiento.

En actividad inicial

Intent activity = new Intent(MyActivity.this,NextActivity.class);
activity.putExtra("myObject", new Gson().toJson(myobject));
startActivity(activity);

En la siguiente actividad

String jsonMyObject;
Bundle extras = getIntent().getExtras();
if (extras != null) {
   jsonMyObject = extras.getString("myObject");
}
MyObject myObject = new Gson().fromJson(jsonMyObject, MyObject.class);

El Parcelable interfaz es una buena forma de pasar un objeto con un Intent.

¿Cómo puedo hacer que mis objetos personalizados sean parcelables? es una respuesta bastante buena sobre cómo usar Parcelable

Los documentos oficiales de Google también incluyen un ejemplo.

Puede utilizar el estado de la aplicación global .

Actualizar:

Personalice y luego agregue esto a su AndroidManifest.xml:

<application android:label="@string/app_name" android:debuggable="true" android:name=".CustomApplication"

Y luego tenga una clase en su proyecto como esta:

package com.example;

import android.app.Application;

public class CustomApplication extends Application {
    public int someVariable = -1;
}

Y como " Se puede acceder a través de getApplication () desde cualquier actividad o servicio ", lo usa así:

CustomApplication application = (CustomApplication)getApplication();
application.someVariable = 123; 

Espero que ayude.

También puede hacer que sus objetos sean serializables y usar los métodos getSerializable y putSerializable del Bundle .

Solución posible:

Bundle bundle = new Bundle();
bundle.putSerializable("key", new CustomObject());

Clase CustomObject:

class CustomObject implements Serializable{
 private SubCustomObject1 sc1;
 private SubCustomObject2 sc2;
}

Objetos subpersonalizados:

class SubCustomObject1 implements Serializable{ }

class SubCustomObject2  implements Serializable{ }

Una forma más de enviar objetos a través del paquete es mediante el bundle.putByteArray
código de muestra

public class DataBean implements Serializable {
private Date currentTime;

public setDate() {
    currentTime = Calendar.getInstance().getTime();
 }

public Date getCurrentTime() {
    return currentTime;
 }
}

poner Object of DataBean en Bundle:

class FirstClass{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Your code...

//When you want to start new Activity...
Intent dataIntent =new Intent(FirstClass.this, SecondClass.class);
            Bundle dataBundle=new Bundle();
            DataBean dataObj=new DataBean();
            dataObj.setDate();
            try {
                dataBundle.putByteArray("Obj_byte_array", object2Bytes(dataObj));

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();

            }

            dataIntent.putExtras(dataBundle);

            startActivity(dataIntent);
}

Conversión de objetos en matrices de bytes

/**
 * Converting objects to byte arrays
 */
static public byte[] object2Bytes( Object o ) throws IOException {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream( baos );
      oos.writeObject( o );
      return baos.toByteArray();
    }

Recuperar objeto del paquete:

class SecondClass{
DataBean dataBean;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Your code...

//Get Info from Bundle...
    Bundle infoBundle=getIntent().getExtras();
    try {
        dataBean = (DataBean)bytes2Object(infoBundle.getByteArray("Obj_byte_array"));
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

Método para obtener objetos de matrices de bytes:

/**
 * Converting byte arrays to objects
 */
static public Object bytes2Object( byte raw[] )
        throws IOException, ClassNotFoundException {
      ByteArrayInputStream bais = new ByteArrayInputStream( raw );
      ObjectInputStream ois = new ObjectInputStream( bais );
      Object o = ois.readObject();
      return o;
    }

Espero que esto ayude a otros amigos.

1.Un ejemplo muy directo y fácil de usar, hacer que el objeto a pasar implemente Serializable.

class Object implements Serializable{
    String firstName;
   String lastName;
}

2.pasar objeto en paquete

Bundle bundle = new Bundle();
Object Object = new Object();
bundle.putSerializable("object", object);

3.Obtener el objeto del paquete como serializable y luego convertirlo en Objeto.

Object object = (Object) getArguments().getSerializable("object");

Esta es una respuesta muy tardía a mi propia pregunta, pero sigue recibiendo atención, así que siento que debo abordarla. La mayoría de estas respuestas son correctas y manejan el trabajo perfectamente. Sin embargo, depende de las necesidades de la aplicación. Esta respuesta se utilizará para describir dos soluciones a este problema.

Solicitud

La primera es la Aplicación , ya que ha sido la respuesta más comentada aquí. La aplicación es un buen objeto para colocar entidades que necesitan una referencia a un contexto. Un `ServerSocket` indudablemente necesitaría un contexto (para E / S de archivos o actualizaciones simples de` ListAdapter`). Yo, personalmente, prefiero esta ruta. Me gustan las aplicaciones, son útiles para la recuperación de contexto (porque pueden volverse estáticas y no es probable que causen una pérdida de memoria) y tienen un ciclo de vida simple.

Servicio

El Servicio` es segundo. Un `Servicio` es en realidad la mejor opción para mi problema porque para eso están diseñados los servicios:

Un servicio es un componente de la aplicación que puede realizar operaciones de larga duración en
el fondo y no proporciona una interfaz de usuario.

Los servicios están ordenados porque tienen un ciclo de vida más definido que es más fácil de controlar. Además, si es necesario, los servicios pueden ejecutarse externamente a la aplicación (es decir, en el arranque). Esto puede ser necesario para algunas aplicaciones o simplemente una función interesante.

Esta no fue una descripción completa de ninguno de los dos, pero dejé enlaces a los documentos para aquellos que quieran investigar más. En general, Servicees mejor para la instancia que necesitaba: ejecutar un ServerSocket en mi dispositivo SPP.

Me encontré con esta pregunta cuando estaba buscando una forma de pasar un objeto Date. En mi caso, como se sugirió entre las respuestas, usé Bundle.putSerializable () pero eso no funcionaría para algo complejo como el DataManager descrito en la publicación original.

Mi sugerencia que dará un resultado muy similar a poner dicho DataManager en la Aplicación o convertirlo en Singleton es usar Dependency Injection y vincular el DataManager a un alcance Singleton e inyectar el DataManager donde sea necesario. No solo obtiene el beneficio de una mayor capacidad de prueba, sino que también obtendrá un código más limpio sin todo el código de la placa de caldera que "pasa dependencias entre clases y actividades". (Robo) Guice es muy fácil de trabajar y el nuevo framework Dagger también parece prometedor.

otra forma simple de pasar un objeto usando un paquete:

• en el objeto de clase, cree una lista estática u otra estructura de datos con una clave
• cuando crea el objeto, colóquelo en la lista / estructura de datos con la clave (por ejemplo, la marca de tiempo larga cuando se crea el objeto)
• cree el método static getObject (clave larga) para obtener el objeto de la lista
• en el paquete, pase la clave, para que pueda obtener el objeto más tarde desde otro punto del código