ฉันกำลังพยายามส่งวัตถุของคลาสลูกค้าของฉันจากที่หนึ่งActivityและแสดงในที่อื่นActivityและแสดงในที่อื่น

รหัสสำหรับคลาสลูกค้า:

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

ฉันต้องการส่งวัตถุจากที่หนึ่งActivityไปยังอีกแล้วแสดงข้อมูลในอื่น ๆActivityไปยังอีกและจากนั้นจะแสดงข้อมูลในที่อื่น ๆ

ฉันจะบรรลุสิ่งนั้นได้อย่างไร

ทางเลือกหนึ่งอาจให้คลาสที่คุณกำหนดเองใช้Serializableอินเทอร์เฟซและจากนั้นคุณสามารถผ่านอินสแตนซ์ของวัตถุในเจตนาพิเศษโดยใช้putExtra(Serializable..)ตัวแปรของIntent#putExtra()วิธีการ

รหัสเทียม :

//To pass:
intent.putExtra("MyClass", obj);

// To retrieve object in second Activity
getIntent().getSerializableExtra("MyClass");

หมายเหตุ: ตรวจสอบให้แน่ใจว่าแต่ละคลาสที่ซ้อนกันของคลาสแบบกำหนดเองหลักของคุณใช้อินเตอร์เฟส Serializable เพื่อหลีกเลี่ยงข้อยกเว้นการทำให้เป็นอนุกรม ตัวอย่างเช่น:

class MainClass implements Serializable {

    public MainClass() {}

    public static class ChildClass implements Serializable {

        public ChildClass() {}
    }
}

ใช้คลาสของคุณกับ Serializable สมมติว่านี่เป็นคลาสเอนทิตีของคุณ:

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

เรากำลังส่งวัตถุที่เรียกว่าdeneจากกิจกรรม X ไปยังกิจกรรม Y ที่ไหนสักแห่งในกิจกรรม X;

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

ในกิจกรรม Y เราได้รับวัตถุ

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

แค่นั้นแหละ.

• การใช้ตัวแปรคงที่ทั่วโลกนั้นไม่ใช่วิธีการทางวิศวกรรมซอฟต์แวร์ที่ดี
• แปลงทุ่งวัตถุเข้าไปดั้งเดิมชนิดข้อมูลที่สามารถเป็นงานที่น่าตื่นเต้น
• การใช้ซีเรียลไลซ์ไลซ์นั้นใช้ได้ แต่ก็ไม่มีประสิทธิภาพในแพลตฟอร์ม Android
• พัสดุถูกออกแบบมาโดยเฉพาะสำหรับ Android และคุณควรใช้ นี่คือตัวอย่างง่ายๆ: การส่งวัตถุที่กำหนดเองระหว่างกิจกรรม Android

คุณสามารถสร้างรหัสพัสดุสำหรับชั้นเรียนของคุณโดยใช้เว็บไซต์นี้

ใช้gsonเพื่อแปลงวัตถุของคุณเป็น JSON และส่งผ่านความตั้งใจ ในกิจกรรมใหม่แปลง JSON เป็นวัตถุ

ในของคุณbuild.gradleเพิ่มสิ่งนี้ในการอ้างอิงของคุณ

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

ในกิจกรรมของคุณแปลงวัตถุเป็น json-string:

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

ในกิจกรรมการรับของคุณแปลง json-string กลับไปเป็นวัตถุดั้งเดิม:

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

สำหรับKotlinมันค่อนข้างเหมือนกัน

ส่งผ่านข้อมูล

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

รับข้อมูล

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

ในขณะที่เรียกกิจกรรม

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

ใน toClass.java ได้รับกิจกรรมโดย

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

โปรดตรวจสอบให้แน่ใจว่าชั้นลูกค้าดำเนินการพัสดุ

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

จากประสบการณ์ของฉันมีวิธีแก้ปัญหาหลักสามข้อแต่ละข้อมีข้อเสียและข้อดี:

1. การใช้พัสดุ

2. การใช้งาน Serializable

3. ใช้ไลบรารีบัสเหตุการณ์น้ำหนักเบาบางประเภท (ตัวอย่างเช่น EventBus ของ Greenrobot หรืออ็อตโตของ Square)

Parcelable - มาตรฐานที่รวดเร็วและ Android แต่มันมีรหัสสำเร็จรูปจำนวนมากและต้องใช้สตริงแบบเข้ารหัสเพื่อการอ้างอิงเมื่อดึงค่าออกเจตนา (ไม่ได้พิมพ์อย่างรุนแรง)

Serializable - ใกล้กับศูนย์ boilerplate แต่มันเป็นวิธีที่ช้าที่สุดและยังต้องใช้สตริงที่มีการกำหนดรหัสแบบยากเมื่อดึงค่าที่ต้องการออกมา (ไม่ได้พิมพ์อย่างรุนแรง)

รถบัสกิจกรรม - ศูนย์ boilerplate วิธีที่เร็วที่สุดและไม่จำเป็นต้องใช้สตริงที่มีการเข้ารหัส แต่จะต้องมีการพึ่งพาเพิ่มเติม (แม้ว่าโดยทั่วไปจะมีน้ำหนักเบา ~ 40 KB)

ฉันโพสต์การเปรียบเทียบรายละเอียดมากเกี่ยวกับวิธีการทั้งสามนี้รวมถึงการวัดประสิทธิภาพ

ฉันพบวิธีการง่าย ๆ & หรูหรา:

• ไม่มีพัสดุ
• ไม่สามารถจัดลำดับได้
• ไม่มีสนามไฟฟ้าสถิต
• ไม่มี Event Bus

วิธีที่ 1

รหัสสำหรับกิจกรรมแรก:

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

รหัสสำหรับกิจกรรมที่สอง:

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

คุณจะพบobjSentและobjReceivedมีเหมือนกันhashCodeดังนั้นจึงเหมือนกัน

แต่ทำไมเราสามารถส่งผ่านวัตถุ java ด้วยวิธีนี้

ที่จริงแล้ว Android binder จะสร้างการอ้างอิง JNI ทั่วโลกสำหรับวัตถุ Java และปล่อยการอ้างอิง JNI ทั่วโลกนี้เมื่อไม่มีการอ้างอิงสำหรับวัตถุ Java นี้ binder จะบันทึกการอ้างอิง JNI ทั่วโลกในวัตถุ Binder

* ข้อควรระวัง: วิธีนี้ใช้ได้เฉพาะกับสองกิจกรรมที่ดำเนินการในกระบวนการเดียวกันมิฉะนั้นให้โยน ClassCastException ที่ (ObjectWrapperForBinder) getIntent (). getExtras (). getBinder ("object_value") *

การกำหนดคลาส ObjectWrapperForBinder

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

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

    public Object getData() {
        return mData;
    }
}

วิธีที่ 2

• สำหรับผู้ส่ง
  1. ใช้วิธีเนทีฟแบบกำหนดเองเพื่อเพิ่มออบเจ็กต์ java ของคุณไปยังตารางอ้างอิงทั่วโลกของ JNI (ผ่าน JNIEnv :: NewGlobalRef)
  2. ใส่จำนวนเต็มคืน (ที่จริงแล้ว JNIEnv :: NewGlobalRef return jobject ซึ่งเป็นตัวชี้เราสามารถส่งมันไปยัง int อย่างปลอดภัย) เพื่อ Intent ของคุณ (ผ่าน Intent :: putExtra)
• สำหรับผู้รับ
  1. รับจำนวนเต็มจาก Intent (ผ่าน Intent :: getInt)
  2. ใช้วิธีเนทีฟแบบกำหนดเองเพื่อกู้คืนอ็อบเจ็กต์ java ของคุณจากตารางอ้างอิงโกลบอล JNI (ผ่าน JNIEnv :: NewLocalRef)
  3. ลบรายการออกจากตารางอ้างอิงทั่วโลกของ JNI (ผ่าน JNIEnv :: DeleteGlobalRef)

แต่วิธีที่ 2 มีปัญหาเล็กน้อย แต่ร้ายแรงหากผู้รับไม่สามารถกู้คืนออบเจ็กต์ java (ตัวอย่างเช่นมีข้อยกเว้นเกิดขึ้นก่อนที่จะกู้คืนออบเจ็กต์จาวาหรือกิจกรรมที่ผู้รับไม่มีอยู่เลย) จากนั้นวัตถุจาวาจะกลายเป็น เด็กกำพร้าหรือหน่วยความจำรั่ววิธีที่ 1 ไม่มีปัญหานี้เนื่องจาก Android binder จะจัดการข้อยกเว้นนี้

วิธีที่ 3

ในการเรียกใช้อ็อบเจกต์ java จากระยะไกลเราจะสร้าง data contract / interface เพื่ออธิบายอ็อบเจกต์ java เราจะใช้ไฟล์ aidl

IDataContract.aidl

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

รหัสสำหรับกิจกรรมแรก

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

รหัสสำหรับกิจกรรมที่สอง:

เปลี่ยน android: attribute attribute ใน AndroidManifest.xml เป็นชื่อกระบวนการที่ไม่ว่างเปล่าเพื่อให้แน่ใจว่ากิจกรรมที่สองทำงานในกระบวนการอื่น

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

ด้วยวิธีนี้เราสามารถผ่านส่วนต่อประสานระหว่างสองกิจกรรมแม้ว่าพวกเขาจะทำงานในกระบวนการที่แตกต่างกันและเรียกวิธีการอินเทอร์เฟซจากระยะไกล

วิธีที่ 4

วิธีที่ 3 ดูไม่ง่ายพอเพราะเราต้องใช้อินเตอร์เฟสช่วยเหลือ หากคุณต้องการทำงานง่ายๆและวิธีการคืนค่าเป็นสิ่งที่ไม่จำเป็นเราสามารถใช้ android.os.Messenger

รหัสสำหรับกิจกรรมแรก (ผู้ส่ง):

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

รหัสสำหรับกิจกรรมที่สอง (ผู้รับ):

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

    }
}

Messenger.send ทั้งหมดจะดำเนินการในตัวจัดการแบบอะซิงโครนัสและตามลำดับ

ที่จริงแล้ว android.os.Messenger ยังเป็นส่วนต่อประสานช่วยเหลือหากคุณมีซอร์สโค้ด android คุณสามารถค้นหาไฟล์ชื่อ IMessenger.aidl

package android.os;

import android.os.Message;

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

คุณสามารถเขียนข้อมูลของวัตถุลงใน Strings และ ints ชั่วคราวและส่งต่อไปยังกิจกรรม แน่นอนว่าคุณจะได้รับข้อมูลที่ส่งผ่าน แต่ไม่ใช่วัตถุ

แต่ถ้าคุณต้องการแสดงมันและไม่ใช้วัตถุในวิธีอื่นหรืออะไรทำนองนั้นมันก็น่าจะเพียงพอแล้ว ฉันทำแบบเดียวกับที่แสดงข้อมูลจากวัตถุหนึ่งในกิจกรรมอื่น

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

คุณสามารถส่งต่อพวกเขาโดยตรงแทนที่จะเป็นไอวอรี่เทมเปิล แต่วิธีนี้มันชัดเจนกว่าในความคิดของฉัน นอกจากนี้คุณสามารถตั้งค่า temars ivars เป็น null เพื่อให้ GarbageCollector ทำความสะอาดได้เร็วขึ้น

โชคดี!

ในหมายเหตุด้าน: แทนที่ toString () แทนที่จะเขียนวิธีการพิมพ์ของคุณเอง

ดังที่ได้กล่าวไว้ในความคิดเห็นด้านล่างนี่คือวิธีที่คุณได้รับข้อมูลของคุณกลับมาในกิจกรรมอื่น:

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

ฉันสร้างคลาสตัวช่วยเดี่ยวที่เก็บวัตถุชั่วคราว

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

แทนที่จะวางวัตถุของคุณไว้ใน Intent ให้ใช้ IntentHelper:

IntentHelper.addObjectForKey(obj, "key");

ภายในกิจกรรมใหม่ของคุณคุณจะได้รับวัตถุ:

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

โปรดทราบว่าเมื่อโหลดแล้ววัตถุจะถูกลบออกเพื่อหลีกเลี่ยงการอ้างอิงที่ไม่จำเป็น

มีสองวิธีที่คุณสามารถเข้าถึงตัวแปรหรือวัตถุในคลาสหรือกิจกรรมอื่น ๆ

A. ฐานข้อมูล

B. ค่ากำหนดที่แชร์

C. การทำให้เป็นอันดับวัตถุ

D. คลาสที่สามารถเก็บข้อมูลทั่วไปสามารถตั้งชื่อเป็น Common Utilities ได้ มันขึ้นอยู่กับคุณ.

E. การส่งข้อมูลผ่าน Intents และ Parcelable Interface

ขึ้นอยู่กับความต้องการของโครงการของคุณ

A. ฐานข้อมูล

SQLiteเป็นฐานข้อมูลโอเพนซอร์ซที่ฝังอยู่ใน Android SQLite รองรับคุณสมบัติฐานข้อมูลเชิงสัมพันธ์มาตรฐานเช่นไวยากรณ์ SQL ธุรกรรมและข้อความสั่งที่เตรียมไว้

สอน

B. ค่ากำหนดที่แชร์

สมมติว่าคุณต้องการเก็บชื่อผู้ใช้ ดังนั้นตอนนี้จะมีสองสิ่งชื่อผู้ใช้ที่สำคัญมูลค่าค่า

วิธีการจัดเก็บ

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

ใช้ putString (), putBoolean (), putInt (), putFloat () และ putLong () คุณสามารถบันทึก dtatype ที่คุณต้องการ

วิธีดึงข้อมูล

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

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

C. การทำให้เป็นอันดับวัตถุ

การรวมวัตถุนั้นใช้หากเราต้องการบันทึกสถานะวัตถุเพื่อส่งผ่านเครือข่ายหรือคุณสามารถใช้เพื่อวัตถุประสงค์ของคุณได้เช่นกัน

ใช้ Java beans และเก็บไว้เป็นหนึ่งในฟิลด์ของเขาและใช้ getters และ setter สำหรับสิ่งนั้น

JavaBeansเป็นคลาส Java ที่มีคุณสมบัติ คิดว่าคุณสมบัติเป็นตัวแปรอินสแตนซ์ส่วนตัว เนื่องจากพวกเขาเป็นส่วนตัววิธีเดียวที่พวกเขาสามารถเข้าถึงได้จากนอกชั้นเรียนของพวกเขาคือผ่านวิธีการในชั้นเรียน เมธอดที่เปลี่ยนค่าของคุณสมบัติเรียกว่าเมธอด setter และเมธอดที่ดึงค่าของคุณสมบัติเรียกว่าเมธอด getter

public class VariableStorage implements Serializable  {

    private String inString;

    public String getInString() {
        return inString;
    }

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

ตั้งค่าตัวแปรในวิธีเมลของคุณโดยใช้

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

จากนั้นใช้วัตถุ serialzation เพื่อทำให้เป็นอันดับวัตถุนี้และในชั้นอื่น ๆ ของคุณ deserialize วัตถุนี้

ในการทำให้เป็นอันดับวัตถุสามารถแสดงเป็นลำดับของไบต์ที่มีข้อมูลของวัตถุรวมทั้งข้อมูลเกี่ยวกับประเภทของวัตถุและประเภทของข้อมูลที่เก็บไว้ในวัตถุ

หลังจากที่วัตถุที่เป็นอนุกรมได้รับการเขียนลงในไฟล์ก็สามารถอ่านได้จากไฟล์และ deserialized นั่นคือข้อมูลประเภทและไบต์ที่เป็นตัวแทนของวัตถุและข้อมูลที่สามารถใช้ในการสร้างวัตถุในหน่วยความจำ

หากคุณต้องการกวดวิชาสำหรับสิ่งนี้อ้างถึง:

• การทำให้เป็นอันดับใน Java (บล็อกโพสต์)

• รับตัวแปรในคลาสอื่น (Stack Overflow)

D. CommonUtilities

คุณสามารถสร้างคลาสได้ด้วยตัวเองซึ่งสามารถมีข้อมูลทั่วไปที่คุณต้องการบ่อยในโครงการของคุณ

ตัวอย่าง

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. การส่งผ่านข้อมูลผ่านความตั้งใจ

โปรดอ้างอิงบทช่วยสอนAndroid - ข้อมูลพัสดุเพื่อส่งผ่านระหว่างกิจกรรมโดยใช้คลาส Parcelableสำหรับตัวเลือกการส่งผ่านข้อมูลนี้

สร้างคลาสของคุณเองCustomerดังต่อไปนี้:

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

}

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

ในxyz activityชั้นเรียนคุณต้องใช้รหัสต่อไปนี้:

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

วิธีที่ดีที่สุดคือการมีคลาส (เรียกว่าการควบคุม) ในแอปพลิเคชันของคุณซึ่งจะเก็บตัวแปรคงที่ประเภท 'ลูกค้า' (ในกรณีของคุณ) เริ่มต้นตัวแปรในกิจกรรม A ของคุณ

ตัวอย่างเช่น:

Control.Customer = CustomerClass;

จากนั้นไปที่กิจกรรม B และดึงข้อมูลจากคลาสควบคุม อย่าลืมกำหนดค่าว่างหลังจากใช้ตัวแปรมิฉะนั้นหน่วยความจำจะสูญเปล่า

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

ตอนนี้คุณต้องการส่งผ่านวัตถุของคลาสนี้ใน startActivity ใช้สิ่งนี้:

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

Serializableนี้ทำงานที่นี่เพราะการดำเนินการ MyClass

หากคุณเลือกใช้วิธีที่ Samuh อธิบายให้จำไว้ว่าสามารถส่งค่าดั้งเดิมได้เท่านั้น นั่นคือค่าที่ parcable ดังนั้นหากวัตถุของคุณมีวัตถุที่ซับซ้อนสิ่งเหล่านี้จะไม่ติดตาม ตัวอย่างเช่นตัวแปรเช่นบิตแมป HashMap ฯลฯ ... สิ่งเหล่านี้เป็นเรื่องยากที่จะผ่านเจตนา

โดยทั่วไปผมจะแนะนำให้คุณส่งประเภทข้อมูลเท่านั้นดั้งเดิมเป็นของแถมเช่น String, int, บูล ฯลฯ ในกรณีของคุณมันจะเป็น: String fname, String lname, และint ageString address

ความคิดเห็นของฉัน: วัตถุที่ซับซ้อนมากขึ้นจะถูกใช้ร่วมกันได้ดีขึ้นโดยการใช้ContentProvider , SDCardฯลฯ นอกจากนี้ยังเป็นไปได้ที่จะใช้ตัวแปรแบบคงที่แต่สิ่งนี้อาจนำไปสู่รหัสผิดพลาดได้อย่างรวดเร็ว ...

แต่อีกครั้งมันเป็นเพียงความเห็นส่วนตัวของฉัน

ฉันใช้พัสดุเพื่อส่งข้อมูลจากกิจกรรมหนึ่งไปยังอีกกิจกรรมหนึ่ง นี่คือรหัสของฉันที่ทำงานได้ดีในโครงการของฉัน

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

ในกิจกรรม A ใช้อย่างนี้:

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

ใน ActivityB ใช้มันเพื่อรับข้อมูล:

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

คุณสามารถลองใช้คลาสนั้นได้ ข้อ จำกัด คือไม่สามารถใช้ภายนอกกระบวนการเดียว

กิจกรรมเดียว:

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

กิจกรรมอื่น ๆ :

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

เริ่มกิจกรรมอื่นจากกิจกรรมนี้และส่งพารามิเตอร์ผ่านทาง Bundle Object

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

ดึงข้อมูลในกิจกรรมอื่น (YourActivity)

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

มันก็โอเคสำหรับประเภทข้อมูลที่เรียบง่าย แต่ถ้าคุณต้องการส่งผ่านข้อมูลที่ซับซ้อนในระหว่างกิจกรรม คุณต้องทำให้มันเป็นอันดับแรก

ที่นี่เรามีรูปแบบพนักงาน

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

คุณสามารถใช้ Gson lib ที่จัดทำโดย google เพื่อจัดทำข้อมูลที่ซับซ้อนเช่นนี้

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

คำถามนี้ถูกกล่าวถึงในคำถาม Stack Overflow อื่น โปรดดูที่วิธีการแก้ปัญหาในการส่งผ่านข้อมูลผ่านเจตนาใช้ Serializable จุดหลักคือเกี่ยวกับการใช้วัตถุที่เก็บภายในข้อมูลที่จำเป็นBundleIntent

 Bundle bundle = new Bundle();

 bundle.putSerializable(key1, value1);
 bundle.putSerializable(key2, value2);
 bundle.putSerializable(key3, value3);

 intent.putExtras(bundle);

ในการแยกค่า:

 Bundle bundle = new Bundle();

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

ข้อดีของSerializableมันคือความเรียบง่าย อย่างไรก็ตามคุณควรพิจารณาใช้Parcelableวิธีการถ้าคุณต้องการข้อมูลจำนวนมากจะถูกโอนย้ายเพราะParcelableถูกออกแบบมาเฉพาะสำหรับ Android Serializableและมันจะมีประสิทธิภาพมากกว่า คุณสามารถสร้างParcelableคลาสโดยใช้:

1. เครื่องมือออนไลน์ - parcelabler
2. ปลั๊กอินสำหรับ Android Studio - เครื่องกำเนิดรหัส Android ที่ทำแผนที่ได้

สร้างคลาสเช่น bean class และใช้Serializableอินเตอร์เฟส จากนั้นเราสามารถส่งผ่านintentวิธีการตัวอย่างเช่น:

intent.putExtra("class", BeanClass);

จากนั้นรับจากกิจกรรมอื่นตัวอย่างเช่น:

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

สร้างสองวิธีในคลาสที่คุณกำหนดเองเช่นนี้

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

ตอนนี้ในกิจกรรมผู้ส่งของคุณทำเช่นนี้

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

และในกิจกรรมรับสัญญาณของคุณ

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

ใช่การใช้วัตถุคงเป็นวิธีที่ง่ายที่สุดในการทำเช่นนี้กับวัตถุที่ไม่สามารถกำหนดเองได้

วัตถุกิจกรรม Android สามารถทำลายและสร้างใหม่ได้ ดังนั้นคุณจะต้องใช้วิธีอื่นในการมองพวกเขา - หรือวัตถุใด ๆ ที่พวกเขาสร้าง !!! - ขึ้น นั่นคือคุณสามารถส่งผ่านการอ้างอิงคลาสแบบคงที่ แต่จากนั้นการจัดการวัตถุ (Java เรียก "การอ้างอิง" เหล่านี้เช่นเดียวกับ SmallTalk แต่พวกเขาไม่ได้อ้างอิงในแง่ของ C หรือแอสเซมบลี) จะไม่ถูกต้องในภายหลังเนื่องจาก "คุณสมบัติ" ของ Android OE เป็นกิจกรรมใด ๆ ที่สามารถทำลายและสร้างขึ้นใหม่ในภายหลัง

คำถามเดิมถามว่า "วิธีส่งผ่านวัตถุจากกิจกรรมหนึ่งไปอีกกิจกรรมหนึ่งใน Android" และไม่มีใครตอบว่า แน่นอนคุณสามารถทำให้เป็นอนุกรม (Serializable, Parcelable, ถึง / จาก JSON) และส่งสำเนาของข้อมูลของวัตถุและวัตถุใหม่ที่มีข้อมูลเดียวกันสามารถสร้าง; แต่มันจะไม่ได้มีการอ้างอิง / จับเดียวกัน นอกจากนี้ยังมีอีกหลายคนที่กล่าวถึงคุณสามารถจัดเก็บข้อมูลอ้างอิงในที่จัดเก็บแบบคงที่ และจะใช้งานได้ยกเว้นว่า Android จะตัดสินใจที่จะทำลายกิจกรรมของคุณ

ดังนั้นเพื่อแก้คำถามเดิมคุณจะต้องมีการค้นหาแบบสแตติกรวมถึงแต่ละวัตถุจะอัปเดตการอ้างอิงเมื่อ / ถ้ามันถูกสร้างขึ้นใหม่ เช่นกิจกรรม Android แต่ละรายการจะ relist ตัวเองถ้า onCreate ถูกเรียก คุณยังสามารถดูว่าบางคนใช้รายการงานเพื่อค้นหากิจกรรมตามชื่อ (ระบบกำลังทำลายอินสแตนซ์ของกิจกรรมนี้ชั่วคราวเพื่อประหยัดพื้นที่ .. getRunningTasks รายการงานเป็นรายการพิเศษของอินสแตนซ์วัตถุล่าสุดของแต่ละกิจกรรม)

สำหรับการอ้างอิง:

หยุด: "กิจกรรมถูกบดบังอย่างสมบูรณ์โดยกิจกรรมอื่น (กิจกรรมอยู่ใน" แบ็คกราวน์ ") กิจกรรมที่หยุดยังมีชีวิตอยู่ ( วัตถุกิจกรรมจะถูกเก็บไว้ในหน่วยความจำมันเก็บข้อมูลสถานะและสมาชิกทั้งหมด แต่ไม่ใช่ ติดกับตัวจัดการหน้าต่าง) อย่างไรก็ตามผู้ใช้จะไม่สามารถมองเห็นได้อีกต่อไปและสามารถถูกฆ่าโดยระบบเมื่อจำเป็นต้องใช้หน่วยความจำที่อื่น "

onDestroy "ระบบกำลังทำลายอินสแตนซ์ของกิจกรรมนี้ชั่วคราวเพื่อประหยัดพื้นที่"

ดังนั้น Message Bus จึงเป็นโซลูชันที่ใช้การได้ มันเป็น "เรือท้องแบน" แทนที่จะพยายามอ้างอิงถึงวัตถุ จากนั้นคุณออกแบบสถาปัตยกรรมของคุณใหม่เพื่อใช้ MessagePassing แทน SequentialCode การดีบักยากขึ้นแบบทวีคูณ แต่มันจะช่วยให้คุณเพิกเฉยต่อการทำความเข้าใจ OperatingEnvironment อย่างมีประสิทธิภาพการเข้าถึงวิธีการของแต่ละวัตถุจะถูกคว่ำเพื่อให้ผู้โทรโพสต์ข้อความและวัตถุนั้นกำหนดตัวจัดการสำหรับข้อความนั้น รหัสมากขึ้น แต่สามารถทำให้แข็งแกร่งด้วยข้อ จำกัด Android OE

หากสิ่งที่คุณต้องการคือกิจกรรมอันดับต้น ๆ (สิ่งทั่วไปในแอพ Android เนื่องจากจำเป็นต้องใช้ "บริบท" ทุกที่) จากนั้นคุณสามารถให้แต่ละกิจกรรมแสดงรายการเป็น "ยอดนิยม" ในพื้นที่ส่วนกลางคงที่เมื่อใดก็ตามที่เรียกว่า onResume จากนั้น AlertDialog ของคุณหรือสิ่งใดก็ตามที่ต้องการบริบทก็สามารถทำได้จากที่นั่น นอกจากนี้ยังเป็นเรื่องเล็กน้อยที่จะใช้ทั่วโลก แต่สามารถลดความซับซ้อนของการส่งบริบทได้ทุกที่และแน่นอนเมื่อคุณใช้ MessageBus ก็จะเป็นไปได้

1. ฉันรู้ว่าคงไม่ดี แต่ดูเหมือนว่าเราถูกบังคับให้ใช้ที่นี่ ปัญหาของ parceables / seriazables คือทั้งสองกิจกรรมมีอินสแตนซ์ที่ซ้ำกันของ object เดียวกัน = เสียหน่วยความจำและ CPU

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

กิจกรรมการโทร

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

กิจกรรมที่เรียกว่า (โปรดทราบว่าonCreate ()และonResume ()อาจถูกเรียกหลายครั้งเมื่อระบบทำลายและสร้างกิจกรรมใหม่)

if (IntentMailBox.content.size()>0)
    level = (Level) IntentMailBox.content.poll();
else
    // Here you reload what you have saved in onPause()

2. อีกวิธีคือการประกาศฟิลด์คงที่ของคลาสที่คุณต้องการส่งผ่านในคลาสนั้น มันจะให้บริการเฉพาะเพื่อจุดประสงค์นี้ อย่าลืมว่ามันอาจจะเป็นโมฆะใน onCreate เนื่องจากแพคเกจแอปของคุณถูกยกเลิกการโหลดจากหน่วยความจำโดยระบบและโหลดใหม่ในภายหลัง

3. โปรดทราบว่าคุณยังคงต้องจัดการวงจรชีวิตของกิจกรรมคุณอาจต้องการเขียนข้อมูลทั้งหมดไปยังการตั้งค่าที่ใช้ร่วมกันเจ็บปวดกับโครงสร้างข้อมูลที่ซับซ้อนเหมือนเดิม

คำตอบข้างต้นเกือบทั้งหมดถูกต้อง แต่สำหรับผู้ที่ไม่ได้ยกเลิกคำตอบเหล่านั้น Android มีความตั้งใจระดับที่มีประสิทธิภาพด้วยความช่วยเหลือของคุณแบ่งปันข้อมูลระหว่างกิจกรรมไม่เพียง แต่ส่วนประกอบอื่น ๆ ของ Android (รับสัญญาณ Broadcasr servises สำหรับเนื้อหา ) ในกิจกรรมของคุณคุณสร้างความตั้งใจ

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

ในกิจกรรมการรับของคุณคุณมี

public class SomeActivity extends AppCompactActivity {

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

}

คุณต้องใช้อินเตอร์เฟส Parceable หรือ Serializable บนวัตถุของคุณเพื่อแบ่งปันระหว่างกิจกรรม เป็นการยากที่จะติดตั้งParcealbe แทนที่จะเป็น Serializableบนวัตถุซึ่งเป็นสาเหตุให้ android มีปลั๊กอินสำหรับการนี้โดยเฉพาะดาวน์โหลดและใช้งาน

ฉันสงสัยมาตลอดว่าทำไมเรื่องนี้ไม่ง่ายเหมือนการเรียกวิธีการของกิจกรรมอื่น ฉันเพิ่งเขียนไลบรารียูทิลิตี้ที่ทำให้มันเกือบจะง่ายเหมือนที่ คุณสามารถตรวจสอบได้ที่นี่ ( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher )

GNLauncherทำให้การส่งวัตถุ / ข้อมูลไปยังกิจกรรมจากกิจกรรมอื่น ๆ เป็นเรื่องง่ายเหมือนกับการเรียกใช้ฟังก์ชันใน tha Activity ด้วยข้อมูลที่ต้องการเป็นพารามิเตอร์ มันแนะนำประเภทความปลอดภัยและกำจัดความเร่งรีบทั้งหมดของการเป็นอันดับ, แนบกับเจตนาโดยใช้คีย์สตริงและการเลิกทำเหมือนกันที่ปลายอีกด้าน

การใช้

กำหนดอินเทอร์เฟซด้วยวิธีการที่คุณต้องการเรียกใช้บนกิจกรรมเพื่อเรียกใช้

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

ใช้อินเทอร์เฟซข้างต้นบนกิจกรรมเพื่อเรียกใช้ แจ้งให้ GNLauncher ทราบเมื่อกิจกรรมพร้อม

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

ในกิจกรรมอื่นรับพร็อกซีไปที่กิจกรรมด้านบนและเรียกใช้วิธีการใด ๆ พร้อมพารามิเตอร์ที่ต้องการ

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

กิจกรรมแรกจะเริ่มขึ้นและวิธีการที่เรียกใช้ด้วยพารามิเตอร์ที่ต้องการ

ข้อกำหนดเบื้องต้น

โปรดดูที่https://github.com/noxiouswinter/gnlib_android/wiki#prerequisitesสำหรับข้อมูลเกี่ยวกับวิธีเพิ่มการอ้างอิง

ส่งผ่านวัตถุจากกิจกรรมหนึ่งไปยังกิจกรรมอื่น

(1) กิจกรรมที่มา

Intent ii = new Intent(examreport_select.this,
                    BarChartActivity.class);

            ii.putExtra("IntentExamResultDetail",
                    (Serializable) your List<ArraList<String>> object here);
            startActivity(ii);

(2) ความเป็นปลายทางปลายทาง

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

ฉันเคยตั้งค่าวัตถุด้วย Pacelable หรือ Serializable เพื่อถ่ายโอน แต่เมื่อใดก็ตามที่ฉันเพิ่มตัวแปรอื่น ๆ ลงในวัตถุ (รุ่น) ฉันต้องลงทะเบียนทั้งหมด มันช่างน่ากลัวเหลือเกิน

มันง่ายสุด ๆ ในการถ่ายโอนวัตถุระหว่างกิจกรรมหรือชิ้นส่วน

Android DataCache

เราสามารถส่งผ่านวัตถุจากกิจกรรมหนึ่งไปยังกิจกรรมอื่น:

SupplierDetails poSuppliersDetails = new SupplierDetails();

ข้างในpoSuppliersDetailsเรามีค่าบางอย่าง ตอนนี้ฉันกำลังส่งวัตถุนี้ไปยังเป้าหมายกิจกรรม:

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

วิธีรับสิ่งนี้ใน ACtivityTwo:

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

ผ่านหนึ่งกิจกรรมไปยังกิจกรรมอื่น:

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

รับค่า:

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

สวัสดีทุกคนเห็นตัวเลือกที่ดีมากมาย แต่ฉันสงสัยว่าทำไม Binding ไม่ถูกใช้?

การผ่านการอ้างอิงไปยังวัตถุดูเหมือนว่าจะมีประสิทธิภาพมากกว่าสำหรับฉันมากกว่าการทำให้เป็นอันดับและวัตถุที่ทำให้เสื่อมเสีย แต่ฉันยังไม่ได้ดำน้ำลึกเพื่อดูว่าเป็นสิ่งที่เกิดขึ้นเบื้องหลังหรือไม่

การสร้าง Binder นั้นง่ายพอ ...

public class MyBinder extends Binder {

    private Object myObject;

    public MyBinder(Object object) {
        myObject = object;
    }

    public Object getObject() {
        return myObject;
    }

}

และการสร้างพัสดุที่จะใช้ไม่ใช่อีเธอร์ที่แย่

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

    };
}

ตรรกะนี้เจ๋งจริงๆเพราะคุณผ่านการอ้างอิงจากกิจกรรมหนึ่งไปอีกกิจกรรมหนึ่ง

ฉันจะแนะนำให้ตรวจสอบ nulls และถ้าอินสแตนซ์ของ Binder คือ MyBinder!

และเพื่อดำเนินการนี้คุณเพียงแค่ ...

ส่งออกไป

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

intent.putExtra("MyParcelable", myParcelable);

ไปเอามันกลับมา

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

Heck ใครบางคนอาจคลั่งไคล้และทำให้ผู้ดูดนี้เป็นคนสามัญอย่างแท้จริง