[java] एक ऑब्जेक्ट को एंड्रॉइड पर एक गतिविधि से दूसरे में कैसे पास करें



Answers

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

हम एक्स गतिविधि से डी गतिविधि नामक वस्तु को भेज रहे हैं। एक्स गतिविधि में कहीं कहीं;

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

वाई गतिविधि में हम वस्तु प्राप्त कर रहे हैं।

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

बस।

Question

मैं एक ग्राहक से अपने ग्राहक वर्ग की वस्तु भेजने पर काम करने की कोशिश कर रहा हूं और इसे किसी अन्य 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 पर डेटा प्रदर्शित करना चाहता हूं।

मैं उसे कैसे प्राप्त कर सकता हूं?




Above answers almost all correct but for those who doesn't undestand those answers Android has powerfull class Intent with help of it you share data between not only activity but another components of Android (broadcasr receiver, servises for content provide we use ContetnResolver class no Intent). In your activity you build intent

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

In your receving activity you have

public class SomeActivity extends AppCompactActivity {

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

}

You have to implement Parceable or Serializable interface on your object in order to share between activities. It is hard to implement Parcealbe rather than Serializable interface on object that's why android has plugin especially for this.Download it and use it




मुझे एक सरल और सुरुचिपूर्ण विधि मिली:

  • कोई पार्सल योग्य नहीं है
  • कोई Serializable नहीं
  • कोई स्टेटिक फील्ड नहीं
  • कोई इवेंट बस नहीं

विधि 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 एक ही objReceived , इसलिए वे समान हैं।

लेकिन हम इस तरह एक जावा वस्तु क्यों पारित कर सकते हैं?

असल में, एंड्रॉइड बाइंडर जावा ऑब्जेक्ट के लिए वैश्विक जेएनआई संदर्भ बनाएगा और इस जावा ऑब्जेक्ट के लिए कोई संदर्भ नहीं होने पर इस वैश्विक जेएनआई संदर्भ को रिलीज़ करेगा। बाइंडर बाइंडर ऑब्जेक्ट में इस वैश्विक जेएनआई संदर्भ को बचाएगा।

* सावधानी: यह विधि केवल तब तक काम करती है जब तक कि दो गतिविधियां एक ही प्रक्रिया में नहीं चलतीं, अन्यथा क्लासकास्टएक्सप्शन (ऑब्जेक्टवापरफोरबिन्डर) getIntent () पर प्राप्त करें। GetExtras ()। GetBinder ("object_value") *

क्लास ऑब्जेक्टवापरफॉरबिन्डर डिफिनेशन

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

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

    public Object getData() {
        return mData;
    }
}

विधि 2

  • प्रेषक के लिए,
    1. जेएनआई वैश्विक संदर्भ तालिका में अपने जावा ऑब्जेक्ट को जोड़ने के लिए कस्टम मूल विधि का उपयोग करें (जेएनआईएनएनवी :: न्यूग्लोबलरफ के माध्यम से)
    2. रिटर्न इंटीजर डालें (वास्तव में, जेएनआईएनएनवी :: न्यूग्लोबल रिफ जॉबेज, जो एक पॉइंटर है, हम इसे सुरक्षित रूप से int में डाल सकते हैं) आपके इरादे (इरादे :: putExtra के माध्यम से)
  • रिसीवर के लिए
    1. इरादे से पूर्णांक प्राप्त करें (इरादे :: getInt के माध्यम से)
    2. जेएनआई वैश्विक संदर्भ तालिका से अपने जावा ऑब्जेक्ट को पुनर्स्थापित करने के लिए कस्टम मूल विधि का उपयोग करें (जेएनआईएनएनवी :: न्यूलोकलरफ के माध्यम से)
    3. जेएनआई वैश्विक संदर्भ तालिका से आइटम हटाएं (जेएनआईएनएनवी :: DeleteGlobalRef के माध्यम से),

लेकिन विधि 2 में थोड़ा लेकिन गंभीर मुद्दा है, यदि रिसीवर जावा ऑब्जेक्ट को पुनर्स्थापित करने में विफल रहता है (उदाहरण के लिए, जावा ऑब्जेक्ट को पुनर्स्थापित करने से पहले कुछ अपवाद होता है, या रिसीवर गतिविधि बिल्कुल मौजूद नहीं होती है), तो जावा ऑब्जेक्ट एक बन जाएगा अनाथ या मेमोरी रिसाव, विधि 1 में यह समस्या नहीं है, क्योंकि एंड्रॉइड बाइंडर इस अपवाद को संभाल लेगा

विधि 3

जावा ऑब्जेक्ट को दूरस्थ रूप से आमंत्रित करने के लिए, हम जावा ऑब्जेक्ट का वर्णन करने के लिए डेटा अनुबंध / इंटरफ़ेस बनाएंगे, हम सहायता फ़ाइल का उपयोग करेंगे

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

दूसरी गतिविधि के लिए कोड:

एंड्रॉइड बदलें: 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 भी एक एड्स इंटरफ़ेस है, यदि आपके पास एंड्रॉइड स्रोत कोड है, तो आप IMessenger.aidl नाम की एक फ़ाइल पा सकते हैं

package android.os;

import android.os.Message;

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



Start another activity from this activity and pass parameters via Bundle Object

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

Retrive data on another activity (YourActivity)

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

This is ok for simple kind of data type. But if u want to pass complex data in between activity. U need to serialize it first.

Here we have Employee Model

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

    getters...
    setters...
}

You can use Gson lib provided by google to serialize the complex data like this

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



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

अब आप प्रारंभिकता में इस वर्ग की वस्तु को पास करना चाहते हैं। बस इसका इस्तेमाल करें:

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

यह यहां काम करता है क्योंकि MyClass Serializable लागू करता है।




I had always wondered why this can't be as simple as calling into a method of the other activity. I recently wrote a utility library that makes it almost as simple as that. You can check it out here( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher ).

GNLauncher makes sending objects/data to an Activity from another Activity etc as easy as calling a function in tha Activity with the required data as parameters. It introduces type safety and removes all the hastles of having to serialize, attaching to the intent using string keys and undoing the same at the other end.

प्रयोग

Define an interface with the methods you want to call on the Activity to launch.

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

Implement the above interface on the Activity to launch into. Also notify GNLauncher when the activity is ready.

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

In the other Activity, get a proxy to the above Activity and call any method with the desired parameters.

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

The first activity will be launched and the method called into with the required parameters.

Prerequisites

Please refer to https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites for information on how to add the dependencies.




I used to set object with Pacelable or Serializable to transfer, but whenever I add other variables to object(model), I have to register it all. It's so nconvenient.

It's super easy to transfer object between activities or fragments.

Android DataCache




ऐसे कुछ तरीके हैं जिनसे आप अन्य वर्गों या गतिविधि में चर या वस्तुओं तक पहुंच सकते हैं।

ए डाटाबेस

बी साझा प्राथमिकताओं।

सी ऑब्जेक्ट serialization।

डी। एक वर्ग जो आम डेटा धारण कर सकता है उसे सामान्य उपयोगिता के रूप में नामित किया जा सकता है। यह आप पर निर्भर करता है।

ई। इरादों और पार्सलबल इंटरफ़ेस के माध्यम से डेटा पास करना।

यह आपकी परियोजना की जरूरतों पर निर्भर करता है।

डाटाबेस

SQLite एक ओपन सोर्स डेटाबेस है जो एंड्रॉइड में एम्बेडेड है। SQLite मानक रिलेशनल डेटाबेस सुविधाओं जैसे SQL वाक्यविन्यास, लेनदेन और तैयार कथन का समर्थन करता है।

Tutorials

बी साझा प्राथमिकताओं

मान लीजिए कि आप उपयोगकर्ता नाम स्टोर करना चाहते हैं। तो अब दो चीजें, एक प्रमुख उपयोगकर्ता नाम, मूल्य मान होगा।

स्टोर कैसे करें

 // 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 () का उपयोग करके आप अपनी वांछित डेटाटाइप को सहेज सकते हैं।

कैसे लाया जाए

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

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

सी ऑब्जेक्ट serialization

ऑब्जेक्ट serlization का उपयोग किया जाता है अगर हम किसी ऑब्जेक्ट स्थिति को किसी नेटवर्क पर भेजने के लिए सहेजना चाहते हैं या आप इसे अपने उद्देश्य के लिए भी उपयोग कर सकते हैं।

जावा बीन्स का उपयोग करें और इसमें अपने खेतों में से एक के रूप में स्टोर करें और इसके लिए गेटर्स और सेटर का उपयोग करें।

JavaBeans जावा कक्षाएं हैं जिनमें गुण हैं। निजी आवृत्ति चर के रूप में गुणों के बारे में सोचें। चूंकि वे निजी हैं, इसलिए उनकी कक्षा के बाहर से ही उन्हें एक्सेस किया जा सकता है, कक्षा में विधियों के माध्यम से। प्रॉपर्टी के वैल्यू को बदलने वाले तरीकों को सेटर विधियों कहा जाता है, और प्रॉपर्टी के मूल्य को पुनर्प्राप्त करने वाले तरीकों को गेटर विधि कहा जाता है।

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

फिर इस ऑब्जेक्ट को क्रमबद्ध करने के लिए ऑब्जेक्ट सीरियलाज़ेशन का उपयोग करें और अपनी दूसरी कक्षा में इस ऑब्जेक्ट को deserialize करें।

क्रमिकरण में एक ऑब्जेक्ट को बाइट्स के अनुक्रम के रूप में दर्शाया जा सकता है जिसमें ऑब्जेक्ट के डेटा के साथ-साथ ऑब्जेक्ट के प्रकार और ऑब्जेक्ट में संग्रहीत डेटा के प्रकार के बारे में जानकारी शामिल होती है।

एक धारावाहिक वस्तु को फ़ाइल में लिखा गया है, इसे फ़ाइल से और deserialized से पढ़ा जा सकता है। यही है, वस्तु और उसके डेटा का प्रतिनिधित्व करने वाली प्रकार की जानकारी और बाइट्स वस्तु को स्मृति में पुन: बनाने के लिए उपयोग की जा सकती हैं।

यदि आप इसके लिए ट्यूटोरियल चाहते हैं तो इसका संदर्भ लें:

डी। सामान्य उपयोगिताएं

आप स्वयं एक कक्षा बना सकते हैं जिसमें आम डेटा हो सकता है जिसे आपको अक्सर अपनी परियोजना में आवश्यकता होती है।

नमूना

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

ई। इरादों के माध्यम से डेटा पास

डेटा पारित करने के इस विकल्प के लिए पार्सेलबल कक्षाओं का उपयोग कर क्रियाकलापों के बीच पारित करने के लिए एंड्रॉइड - पार्सल डेटा ट्यूटोरियल देखें।




यदि आप समूह का वर्णन करने का तरीका चुनते हैं, तो याद रखें कि केवल आदिम मूल्य ही भेजे जा सकते हैं। यही वह मूल्य है जो पारदर्शी हैं। इसलिए, यदि आपके ऑब्जेक्ट में जटिल ऑब्जेक्ट्स हैं तो इनका पालन नहीं किया जाएगा। उदाहरण के लिए, बिटमैप, हैश मैप आदि जैसे चर ... ये इरादे से गुजरने के लिए मुश्किल हैं।

आम तौर पर मैं सलाह देता हूं कि आप स्ट्रिंग, इंट, बूलियन इत्यादि जैसे एक्स्ट्रा के रूप में केवल आदिम डेटाटाइप भेजें। आपके मामले में यह होगा: String lname , String lname , int age , और String address

मेरी राय: सामग्री प्रदाता , एसडीकार्ड इत्यादि को लागू करके अधिक जटिल वस्तुओं को बेहतर साझा किया जाता है। स्थिर वैरिएबल का उपयोग करना भी संभव है, लेकिन यह तेजी से त्रुटि-प्रवण कोड का कारण बन सकता है ...

लेकिन फिर, यह सिर्फ मेरी व्यक्तिपरक राय है।




आप उस वर्ग का उपयोग करने की कोशिश कर सकते हैं। सीमा यह है कि इसका उपयोग एक प्रक्रिया के बाहर नहीं किया जा सकता है।

एक गतिविधि:

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



Hello all I see a lot of good options but I was wondering why Binding hasn't been used?

Passing a reference to an object just seems more efficient to me than serializing and desterilizing objects, but I have not done a deep dive to see if that is what is going on behind the scenes.

Creating a Binder is simple enough...

public class MyBinder extends Binder {

    private Object myObject;

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

    public Object getObject() {
        return myObject;
    }

}

And creating the parcelable to use it isn't that bad ether.

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

    };
}

This logic is really cool because you are actually passing a reference from activity to activity.

I would advise checking for nulls and if the instanceof Binder is MyBinder!

and to implement this you just...

Send it off

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

intent.putExtra("MyParcelable", myParcelable);

Get it back

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

Heck someone could get all crazy and make this sucker a true generic.




अपनी ऑब्जेक्ट को JSON में बदलने और इसे मंशा के माध्यम से पास करने के लिए gson का उपयोग करें। नई गतिविधि में JSON को किसी ऑब्जेक्ट में कनवर्ट करें।

उदाहरण:

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

और आपकी अगली गतिविधि में, जहां आप ऑब्जेक्ट पास करना चाहते हैं:

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



Android Activity objects can be destroyed and reconstituted. So, you will need to use another approach to look them - or any object they create !!! - up. That is, you could pass as static class reference but then the object handle (Java calls these "references", as does SmallTalk; but they are not references in the sense of C or assembly) will be possibly invalid later because a "feature" of Android OE is any Activity can be annihilated and reconstituted later.

The original question asked "How to pass object from one activity to another in Android" and nobody has answered that. For sure, you can serialized (Serializable, Parcelable, to/from JSON) and pass a copy of the object's data and a new object having the same data could be created; but it will NOT have the same references/handles. Also, many others mentioned you can store the reference in a static store. And that will work unless Android decides to onDestroy your Activity.

So, to really solve the original question you would need a static lookup plus each object will update its reference when/if it is recreated. Eg each Android Activity would relist itself if its onCreate is called. You can also see how some people use the task list to search out an Activity by name. (system is temporarily destroying this instance of the activity to save space..getRunningTasks, the task list is effectively a specialized listing of the most recent object instance of each Activity).

For reference:

Stopped: "The activity is completely obscured by another activity (the activity is now in the "background"). A stopped activity is also still alive (the Activity object is retained in memory , it maintains all state and member information, but is not attached to the window manager). However, it is no longer visible to the user and it can be killed by the system when memory is needed elsewhere."

onDestroy "system is temporarily destroying this instance of the activity to save space."

So, the Message Bus is a workable solution. It basically "punts". Rather than try to have references to objects; then you re-architect your design to use MessagePassing instead of SequentialCode. Exponentially harder to debug; but it lets you ignore these sort of OperatingEnvironment understandings. Effectively, each object method access is inverted so the caller posts a Message and the object itself defines a handler for that message. Lots more code but can make it robust with the Android OE restrictions.

If all you want is the top Activity (typical thing in Android apps due to "Context" being needed everywhere), then you can just have each Activity lists itself as "top" in the static global space whenever its onResume is called. Then your AlertDialog or whatever which needs a context can just grab it from there. Also, its a bit yucky to use a global but can simplifying passing a Context up and down everywhere and, for sure, when you use a MessageBus then IT IS global anyways.




Create two methods in your custom Class like this

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

Now in your sender Activity do like this

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

And in your receiver Activity

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



एक गतिविधि बुलाते समय

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



Related