Comment passer d'un objet à partir d'une activité à l'autre sur Android

Mettre en œuvre votre classe Sérialisable. Supposons que c'est votre classe d'entité:

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;
}

Nous sommes l'envoi de l'objet appelé dene de X de l'activité pour Y activité. Quelque part dans X de l'activité;

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

En Y de l'activité de l'objet.

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

Que c'est.

Tout en appelant à une activité

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

Dans toClass.java recevez l'activité par

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

Assurez-vous que la clientèle de la classe implémente 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();
    }

Utilisation gson pour convertir votre objet en JSON et le passer à travers intention. Dans la nouvelle Activité de convertir au format JSON à un objet.

Dans votre build.gradle, ajouter à vos dépendances

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

Dans votre Activité, de convertir l'objet en json-chaîne:

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

À réception de votre Activité, de les convertir au format json-chaîne à l'objet d'origine:

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

Pour Kotlin c'est tout à fait le même

Transmettre les données

val gson = Gson()
val intent = Intent(this, YourActivity::class.java)
intent.putExtra("identifier", gson.toJson(your_object))
startActivity(intent)

Recevoir les données

val gson = Gson()
val yourObject = gson.fromJson<YourObject>(intent.getStringExtra("identifier"), YourObject::class.java)

J'ai trouvé un simple & élégant méthode:

• PAS Parcelable
• PAS Sérialisable
• PAS de Champ Statique
• Aucun Cas, Bus

Méthode 1

Code pour la première activité:

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

De Code pour la deuxième activité:

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

vous trouverez objSent & objReceived ont la même hashCode, de sorte qu'ils sont identiques.

Mais pourquoi ne pouvons-nous passer d'un objet java de cette façon?

En fait, android classeur de créer de la JNI mondiale de référence pour java objet et de le libérer de ce mondial JNI de référence quand il n'y a pas de référence pour cet objet java. classeur de sauver ce JNI mondiale de référence dans l'objet de Classeur.

*ATTENTION: cette méthode ne fonctionne que si les deux activités exécutées dans le même processus, autrement jeter ClassCastException au (ObjectWrapperForBinder)getIntent().getExtras().getBinder("object_value") *

classe ObjectWrapperForBinder defination de

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

    public ObjectWrapperForBinder(Object data) {
        mData = data;
    }

    public Object getData() {
        return mData;
    }
}

Méthode 2

• pour l'expéditeur,
  1. utilisation personnalisée méthode native pour ajouter votre objet java à la JNI mondiale de la table de référence(via JNIEnv::NewGlobalRef)
  2. mettre le retour entier (en fait, JNIEnv::NewGlobalRef retour jobject, qui est un pointeur, on peut la convertir en int en toute sécurité) à votre Intention(via Intention::putExtra)
• pour le récepteur
  1. obtenir de l'entier de l'Intention(via Intention::getInt)
  2. utilisation personnalisée méthode native pour restaurer votre objet java à partir de JNI mondiale de la table de référence (via JNIEnv::NewLocalRef)
  3. supprimer l'élément de la JNI mondiale de la table de référence(via
     JNIEnv::DeleteGlobalRef),

Mais la Méthode 2 a un peu, mais sérieux, si le récepteur ne parviennent pas à rétablir l'objet java (par exemple, une exception se produire avant la restauration de l'objet java, ou le récepteur de l'Activité, il n'existe pas), puis de l'objet java deviendra un orphelin ou de fuite de mémoire,
Méthode 1 n'ont pas ce problème, parce qu'android classeur de gérer cette exception

Méthode 3

D'invoquer l'objet java à distance, nous allons créer un contrat de données/interface pour décrire l'objet java, nous allons utiliser l'aidl fichier

IDataContract.aidl

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

Code pour la première activité

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

De Code pour la deuxième activité:

changer le android:processus d'attribut dans AndroidManifest.xml pour un non-vide nom du processus pour s'assurer que la deuxième activité de l'exécuter dans un autre processus

    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 cette façon, nous pouvons passer d'une interface entre deux activités, même si ils courent dans les différents processus, et d'appeler la méthode de l'interface à distance

Méthode 4

méthode 3 ne semblent pas assez simple parce que nous devons mettre en œuvre une aidl interface.
Si vous voulez juste faire une tâche simple et la méthode de la valeur de retour est inutile, on peut utiliser android.os.Messenger

Code pour la première activité( expéditeur):

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

De Code pour la deuxième activité ( récepteur ):

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();
        }

    }
}

Tous le Messager.envoyez s'exécuter dans un Gestionnaire de façon asynchrone, et de manière séquentielle.

En fait, android.os.Messenger est un aidl de l'interface, si vous avez le code source android, vous pouvez trouver un fichier nommé IMessenger.aidl

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

Il ya un couple de façons dont vous pouvez accéder à des variables ou des objets dans d'autres classes ou de l'Activité.

A. Base De Données

B. Partagé préférences.

C. sérialisation d'un Objet.

D. Une classe qui peut contenir des données communes peuvent être désignés comme des Utilitaires Communs. Il dépend de vous.

E. la transmission des données par le biais d'Intentions et de l'Interface Parcelable.

Il dépend des besoins de votre projet.

A. Base De Données

SQLite est une base de données open source qui est intégré dans Android. SQLite prend en charge la norme de base de données relationnelle fonctionnalités comme la syntaxe SQL, des opérations et déclarations préparées à l'avance.

Tutoriels

B. Partagé préférences

Supposons que vous souhaitez stocker le nom d'utilisateur. Donc, il y a maintenant de deux choses l'une, un clé nom d'utilisateur, valeur valeur.

Comment stocker

 //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();

À l'aide de putString(), putBoolean(), putInt(), putFloat(), et putLong (), vous pouvez enregistrer votre choix dtatype.

Comment extraire les

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

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

C. sérialisation d'un Objet

Objet serlization est utilisé si l'on veux enregistrer un état de l'objet à envoyer sur un réseau ou vous pouvez l'utiliser pour votre usage aussi.

Utiliser Java beans et de les stocker dans un de ses champs et de l'utilisation des getters et setter pour que.

JavaBeans sont des classes Java qui ont des propriétés. Pensez
propriétés privées variables d'instance. Depuis qu'ils sont privés, la seule façon
ils peuvent être accessibles à partir de l'extérieur de leur classe par le biais de méthodes dans la classe. Les méthodes de modifier une valeur de la propriété sont appelées des méthodes de définition, et les méthodes permettant d'extraire une valeur de la propriété sont appelées des méthodes de lecture.

public class VariableStorage implements Serializable  {

    private String inString;

    public String getInString() {
        return inString;
    }

    public void setInString(String inString) {
        this.inString = inString;
    }
}

Définir la variable dans votre mail, en utilisant la méthode

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

Puis utiliser l'objet serialzation de sérialiser et dans d'autres classe désérialiser cet objet.

Dans la sérialisation d'un objet peut être représenté comme une séquence d'octets qui comprend les données de l'objet ainsi que des informations sur le type de l'objet et les types de données stockées dans l'objet.

Après un objet sérialisé a été écrit dans un fichier, il peut être lu à partir du fichier et désérialisé. C'est le type d'information et d'octets qui représentent l'objet et ses données peuvent être utilisées pour recréer l'objet en mémoire.

Si vous voulez un tutoriel pour cela se référer à:

• La sérialisation en Java (blog)

• Obtenez variable dans d'autres classes (Débordement De Pile)

D. CommonUtilities

Vous pouvez faire une classe par vous-même qui peut contenir les données qui vous avez souvent besoin dans votre projet.

Échantillon

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. la transmission des données à travers les intentions de

Veuillez consulter le tutoriel Android – Parcelle de données à transmettre entre les Activités à l'aide de Parcelable classes pour cette option de transmission de données.

Le meilleur moyen est d'avoir une classe (appelons-le Contrôle) dans votre application qui va contenir une variable statique de type "Client" (dans votre cas). Initialiser la variable dans votre Activité A.

Par exemple:

Control.Customer = CustomerClass;

Ensuite, allez à l'Activité de B et récupérer à partir de la classe de Contrôle. N'oubliez pas d'attribuer une valeur nulle après l'utilisation de la variable, sinon, de mémoire, sera gaspillé.

Si vous choisissez d'utiliser la voie Samuh décrit, n'oubliez pas que seules les valeurs primitives peuvent être envoyés. Cela signifie que les valeurs qui sont parcable. Donc, si votre objet contient des objets complexes elles ne pourront pas suivre. Par exemple, des variables comme Bitmap, HashMap, etc... sont difficiles à passer par l'intention.

En général, je vous conseillerais de vous envoyer seulement les types de données primitifs que les extras, comme String, int, boolean, etc. Dans votre cas, il serait: String fname, String lname, int age, et String address.

Mon avis: des objets Plus complexes sont mieux partagés par la mise en œuvre d'un ContentProvider, SDCard, etc. Il est également possible d'utiliser un variable statique, mais cela peut rapidement conduire à des erreurs de code...

Mais encore une fois, c'est juste mon opinion subjective.

Vous pouvez essayer d'utiliser cette classe. La limitation est qu'il ne peut pas être utilisé en dehors d'un processus.

Une activité:

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

Autre activité:

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

Cette question est également abordée dans un autre Débordement de Pile question. Jetez un oeil à une solution à la transmission des données par le biais de l'intention à l'aide de Serializable. Le point principal est sur l'utilisation de Bundle objet qui stocke les données nécessaires à l'intérieur de Intent.

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

Pour extraire des valeurs:

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

Avantage de Serializable est sa simplicité. Toutefois, vous devriez envisager d'utiliser Parcelable méthode si vous avez besoin de beaucoup de données à transférer, parce que Parcelable est spécialement conçu pour Android et il est plus efficace que Serializable. Vous pouvez créer Parcelable classe à l'aide de:

1. un outil en ligne - parcelabler
2. un plugin pour Android Studio - Android Parcelable générateur de code

Créer deux méthodes dans votre Classe personnalisée comme ce

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();
} 
}
}

Maintenant dans votre expéditeur de l'Activité de faire comme ceci

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

Et dans votre Activité récepteur

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

Android Activité les objets peuvent être détruits et reconstitué. Ainsi, vous aurez besoin d'utiliser une autre approche pour rechercher - ou n'importe quel objet ils créent!!! - jusqu'. Qui est, vous pourriez passer comme statique de la classe de référence, mais alors le handle d'objet (Java appelle ces "références", comme SmallTalk; mais ils ne sont pas des références dans le sens de C ou de l'assemblée) sera peut-être pas valide tard, car il est une "fonctionnalité" de Android OE est toute Activité peut être anéanti et reconstitué plus tard.

L'original de la question posée "Comment passer de l'objet à partir d'une activité à l'autre dans Android" et personne n'a répondu. Pour sûr, vous pouvez sérialisé (Serializable, Parcelable, depuis JSON) et de transmettre une copie des données de l'objet et un nouvel objet ayant les mêmes données pourraient être créés; mais il n'aura PAS les mêmes références/poignées. Aussi, beaucoup d'autres l'ont mentionné, vous pouvez stocker la référence statique le magasin. Et qui va travailler à moins d'Android décide de onDestroy de votre Activité.

Donc, pour vraiment résoudre la question d'origine vous avez besoin d'une statique de recherche de plus chaque objet de mise à jour de sa référence quand/si elle est recréée. E. g. chaque Android Activité est susceptible de remettre en vente lui-même si ses onCreate est appelé. Vous pouvez également voir comment certaines personnes utilisent la liste des tâches à la recherche d'une Activité en nom. (le système est temporairement en train de détruire cette instance de l'activité pour économiser de l'espace..getRunningTasks, la liste des tâches est effectivement spécialisé de la liste de la plus récente de l'objet instance de chaque Activité).

Pour référence:

Arrêté:
"L'activité est complètement masqué par une autre activité (l'activité est maintenant dans le "fond"). Un arrêt de l'activité est également encore en vie (le Activité objet est conservé dans la mémoire, il maintient l'ensemble de l'état et de l'information des membres, mais n'est pas attaché à la fenêtre du gestionnaire). Cependant, il n'est plus visible pour l'utilisateur et il peut être tué par le système lorsque la mémoire est nécessaire ailleurs."

onDestroy
"le système est temporairement de détruire cette instance de l'activité pour économiser de l'espace."

Donc, le Bus de Message est une solution viable. Il fondamentalement des "plates". Plutôt que d'essayer d'avoir des références à des objets; puis vous re-architecte de votre conception à l'utilisation MessagePassing au lieu de SequentialCode. Exponentiellement plus difficile à déboguer; mais elle permet d'ignorer ces sortes de OperatingEnvironment de compréhensions. Effectivement, chaque objet de la méthode d'accès est inversé de sorte que l'appelant envoie un Message et l'objet lui-même définit un gestionnaire pour ce message. Beaucoup plus de code, mais peut le rendre robuste avec de l'Android OE restrictions.

Si tout ce que vous voulez, c'est le top de l'Activité (chose typique dans les applications Android à cause du "Contexte" d'être partout), alors vous pouvez juste avoir à chaque Activité listes de lui-même comme "top" de la statique global de l'espace à chaque fois que son onResume est appelé. Ensuite, votre AlertDialog ou tout ce qui a besoin d'un contexte suffit de prendre à partir de là. Aussi, il est un peu dégoûtant à utiliser une approche globale, mais peut simplifier le passage d'un Cadre en haut et en bas, partout, et, bien sûr, lorsque vous utilisez un MessageBus puis IL EST global, de toute façon.

Réponses ci-dessus, presque tous les corriger, mais pour ceux qui n'ont pas de comprendre ces réponses
Android a puissant de la classe Intention avec l'aide de vous partager des données entre non seulement l'activité mais d'un autre des composants d'Android (broadcasr récepteur, services internes connexes pour fournir du contenu, nous utilisons ContetnResolver classe pas l'Intention).
Dans votre activité, vous construire intention

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

Dans receving votre activité, vous avez

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

Vous avez à mettre en œuvre Parceable ou l'interface Serializable sur votre objet afin de le partager entre les activités. Il est difficile de mettre en œuvre Parcealbe plutôt que Serializable interface de l'objet c'est pourquoi android a plugin spécialement pour cela.Télécharger et de l'utiliser

Pass objet d'une activité à une autre activité.

(1) source de l'activité

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

(2) destination acitivité

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

Nous pouvons passer de l'objet à partir d'une activité à une autre activité:

SupplierDetails poSuppliersDetails = new SupplierDetails();

À l'intérieur de poSuppliersDetails nous avons certaines valeurs. Maintenant, je suis l'envoi de cet objet pour l'activité cible:

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

Comment obtenir ce ACtivityTwo:

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

Bonjour à tous, je vois beaucoup de bonnes options, mais je me demandais pourquoi la Liaison n'a pas été utilisé?

De passer une référence à un objet me semble plus efficace pour moi que la sérialisation et la desterilizing objets, mais je n'ai pas fait une plongée profonde, afin de voir si ce qui se passe derrière les coulisses.

La création d'un Classeur est assez simple...

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

Et de la création de la parcelable pour l'utiliser, il n'est pas mauvais de l'éther.

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];
}
};
}

Cette logique, c'est vraiment cool, parce que vous êtes réellement en passant une référence d'activité.

Je vous conseille de vérifier pour les valeurs null et si le instanceof Binder est MyBinder!

et de mettre en œuvre ce que vous venez de...

Envoyer

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

Récupérer

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

Diable quelqu'un pourrait obtenez tous fous et en faire ce con un vrai générique.