අභිප්‍රාය භාවිතා කරමින් එක් ඇන්ඩ්‍රොයිඩ් ක්‍රියාකාරකමකින් තවත් වස්තුවකට වස්තුවක් යවන්නේ කෙසේද?

පංති අභිප්‍රායයේ ක්‍රමය භාවිතා කර අභිරුචි ආකාරයේ වස්තුවක් එක් ක්‍රියාකාරකමකින් තවත් ක්‍රියාකාරකමක් වෙත යොමු කරන්නේ කෙසේද?putExtra()

ඔබ නිකම්ම වස්තූන් පසුකර යන්නේ නම්, මේ සඳහා Parcelable නිර්මාණය කර ඇත. ජාවාහි ස්වදේශීය අනුක්‍රමිකකරණය භාවිතා කිරීමට වඩා එය භාවිතා කිරීමට ටිකක් වැඩි උත්සාහයක් අවශ්‍ය වේ, නමුත් එය වේගවත් ය (මම අදහස් කරන්නේ මාර්ගය, WAY වේගවත්).

ලේඛනයෙන්, ක්‍රියාත්මක කරන්නේ කෙසේද යන්න පිළිබඳ සරල උදාහරණයක්:

// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;

    /* everything below here is for implementing Parcelable */

    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    }

    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    }

    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

        public MyParcelable[] newArray(int size) {
            return new MyParcelable[size];
        }
    };

    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
    }
}

දී ඇති පාර්සලයකින් ලබා ගැනීමට ඔබට එක් ක්ෂේත්‍රයකට වඩා ඇති බව නිරීක්ෂණය කරන්න, ඔබ මෙය කළ යුත්තේ ඔබ ඒවා තැබූ අනුපිළිවෙලට ය (එනම්, FIFO ප්‍රවේශයකින්).

ඔබ ඔබේ වස්තූන් ඇති වරක් ක්රියාත්මක Parcelableඑය ඔබගේ බවට දායකකර ප්රශ්නයක් විතරයි අපේක්ෂාවන් සමග putExtra () :

Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);

එවිට ඔබට getParcelableExtra () සමඟ ඒවා ආපසු ඇද ගත හැකිය :

Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");

ඔබේ වස්තු පන්තිය පාර්සල් කළ හැකි සහ අනුක්‍රමික කළ හැකි නම්, ඔබ පහත සඳහන් දේවලින් එකක් බවට පත් කිරීමට වග බලා ගන්න:

i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);

ඔබේ වස්තුව යම් ආකාරයක නූල් නිරූපණයකට අනුක්‍රමික කිරීමට ඔබට අවශ්‍ය වනු ඇත. හැකි එක් නූල් නිරූපණයක් JSON වන අතර, ඇන්ඩ්‍රොයිඩ් හි JSON වෙත / සිට අනුක්‍රමික කිරීමට පහසුම ක්‍රමයක් නම්, ඔබ මගෙන් ඇසුවොත්, ගූගල් GSON හරහා .

එවැනි අවස්ථාවකදී ඔබ නූල් ප්‍රතිලාභ අගය (new Gson()).toJson(myObject);ලබා දී නූල් අගය ලබාගෙන භාවිතා කරන්නfromJson එය නැවතත් ඔබේ වස්තුව බවට පත් කරන්න.

කෙසේ වෙතත්, ඔබේ වස්තුව ඉතා සංකීර්ණ නොවේ නම්, එය පොදු කාර්යයට වඩා වටින්නේ නැති අතර, ඒ වෙනුවට වෙනම අගයන් පසු කිරීම ගැන සලකා බැලිය හැකිය.

ඔබට අභිප්‍රාය හරහා අනුක්‍රමික වස්තුව යැවිය හැකිය

// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);


//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");

And 

Class ClassName implements Serializable {
} 

ඔබ යෙදුමක් තුළ දත්ත ලබා දෙන බව ඔබ දන්නා අවස්ථා සඳහා, "ග්ලෝබල්" භාවිතා කරන්න (ස්ථිතික පන්ති වැනි)

මෙන්න මේ කාරණය සම්බන්ධයෙන් ඩයැන් හැක්බර්න් (හැක්බොඩ් - ගූගල් ඇන්ඩ්‍රොයිඩ් මෘදුකාංග ඉංජිනේරුවරයෙකුට) පැවසිය යුතු දේ:

එකම ක්‍රියාවලියක් තුළ ක්‍රියාකාරකම් ක්‍රියාත්මක වන බව ඔබ දන්නා අවස්ථා සඳහා, ඔබට ගෝලීය හරහා දත්ත බෙදා ගත හැකිය. උදාහරණයක් ලෙස, ඔබට ගෝලීය විය හැකි අතර HashMap<String, WeakReference<MyInterpreterState>> ඔබ නව MyInterpreterState එකක් සාදන විට ඒ සඳහා අද්විතීය නමක් ගෙන එය හැෂ් සිතියමට දමන්න; එම තත්වය වෙනත් ක්‍රියාකාරකමකට යැවීමට, අද්විතීය නම හැෂ් සිතියමට ඇතුළත් කරන්න. දෙවන ක්‍රියාකාරකම ආරම්භ කළ විට එයට ලැබෙන නම සමඟ හැෂ් සිතියමෙන් MyInterpreterState ලබා ගත හැකිය.

ඔබේ පන්තිය අනුක්‍රමික හෝ පාර්සල් කළ හැකි දෑ ක්‍රියාත්මක කළ යුතුය.

public class MY_CLASS implements Serializable

එය අවසන් වූ පසු ඔබට putExtra හි වස්තුවක් යැවිය හැකිය

intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

අමතර දේ ලබා ගැනීම සඳහා ඔබ කළ යුත්තේ එයයි

Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");

ඔබේ පන්තිය පාර්සල් කළ හැකි භාවිතය ඊළඟට ක්‍රියාත්මක කරන්නේ නම්

MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");

එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි: ඩී

වේගවත් අවශ්‍යතාව සඳහා කෙටි පිළිතුර

1. ඔබේ පන්තිය අනුක්‍රමිකව ක්‍රියාත්මක කරන්න.

ඔබට අභ්‍යන්තර පංති තිබේ නම් ඒවා අනුක්‍රමිකකරණයට ක්‍රියාත්මක කිරීමට අමතක නොකරන්න !!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2. ඔබේ වස්තුව අභිප්‍රාය තුළට දමන්න

 Intent intent = new Intent(SportsAct.this, SportSubAct.class);
            intent.putExtra("sport", clickedObj);
            startActivity(intent);

3. ඔබේ වස්තුව අනෙක් ක්‍රියාකාරකම් පන්තියට ලබා ගන්න

Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");

ඔබේ වස්තු පන්තිය ක්‍රියාත්මක Serializableකරන්නේ නම්, ඔබට වෙනත් කිසිවක් කිරීමට අවශ්‍ය නැත, ඔබට අනුක්‍රමික වස්තුවක් පසු කළ හැකිය.
ඒක තමයි මම පාවිච්චි කරන්නේ.

ඔබේ පන්තියේ අනුක්‍රමිකව ක්‍රියාත්මක කරන්න

public class Place implements Serializable{
        private int id;
        private String name;

        public void setId(int id) {
           this.id = id;
        }
        public int getId() {
           return id;
        }
        public String getName() {
           return name;
        }

        public void setName(String name) {
           this.name = name;
        }
}

එවිට ඔබට මෙම වස්තුව අභිප්‍රායයෙන් සම්මත කළ හැකිය

     Intent intent = new Intent(this, SecondAct.class);
     intent.putExtra("PLACE", Place);
     startActivity(intent);

දෙවන ක්‍රියාකාරකම මඟින් ඔබට මෙවැනි දත්ත ලබා ගත හැකිය

     Place place= (Place) getIntent().getSerializableExtra("PLACE");

නමුත් දත්ත විශාල වූ විට මෙම ක්‍රමය මන්දගාමී වනු ඇත.

ඔබට වෙනත් පංතිවල හෝ ක්‍රියාකාරකම් වල විචල්‍යයන් හෝ වස්තු වෙත ප්‍රවේශ විය හැකි ක්‍රම කිහිපයක් තිබේ.

A. දත්ත සමුදාය

හවුල් මනාපයන්.

C. වස්තු අනුක්‍රමිකකරණය.

D. පොදු දත්ත රඳවා ගත හැකි පන්තියක් ඔබ මත රඳා පවතින පොදු උපයෝගිතා ලෙස නම් කළ හැකිය.

E. අභිප්‍රායන් සහ පාර්සල් කළ හැකි අතුරුමුහුණත හරහා දත්ත සම්ප්‍රේෂණය කිරීම.

එය ඔබගේ ව්‍යාපෘති අවශ්‍යතා මත රඳා පවතී.

A. දත්ත සමුදාය

SQLite යනු ඇන්ඩ්‍රොයිඩ් තුළට කාවැදී ඇති විවෘත මූලාශ්‍ර දත්ත ගබඩාවකි. SQLite, සින්ටැක්ස්, ගනුදෙනු සහ සූදානම් කළ ප්‍රකාශ වැනි සම්මත සම්බන්ධතා දත්ත සමුදා විශේෂාංග සඳහා සහය දක්වයි.

නිබන්ධන - http://www.vogella.com/articles/AndroidSQLite/article.html

බී සාමූහික මනාප

ඔබට පරිශීලක නාමය ගබඩා කිරීමට අවශ්‍ය යැයි සිතමු. එබැවින් යතුරු පරිශීලක නාමයක් වන අගය අගය යන කරුණු දෙකක් දැන් ඇත .

ගබඩා කරන්නේ කෙසේද

 // Create an 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. වස්තු අනුක්‍රමිකකරණය

වස්තු තත්වයක් ජාලය හරහා යැවීම සඳහා අපට සුරැකීමට අවශ්‍ය නම් හෝ ඔබේ අරමුණු සඳහාද එය භාවිතා කළ හැකිය.

ජාවා බෝංචි භාවිතා කර එය ඔහුගේ එක් ක්ෂේත්‍රයක් ලෙස ගබඩා කර ඒ සඳහා ගෙටර්ස් සහ සෙටර් භාවිතා කරන්න

ජාවාබීන්ස් යනු ගුණාංග ඇති ජාවා පන්ති වේ. ගුණාංග පුද්ගලික නිදර්ශන විචල්‍යයන් ලෙස සිතන්න. ඔවුන් පුද්ගලික බැවින්, ඔවුන්ගේ පන්තියෙන් පිටත සිට ඔවුන්ට ප්‍රවේශ විය හැකි එකම ක්‍රමය පන්තියේ ක්‍රම වේ. දේපලක වටිනාකම වෙනස් කරන ක්‍රම සෙටර් ක්‍රම ලෙසත්, දේපලක වටිනාකම ලබා ගන්නා ක්‍රම ගැටර් ක්‍රම ලෙසත් හැඳින්වේ.

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

ඉන්පසු මෙම වස්තුව අනුක්‍රමික කිරීමට වස්තුව අනුක්‍රමිකකරණය භාවිතා කරන්න.

අනුක්‍රමිකකරණයේදී, වස්තුවක දත්ත මෙන්ම වස්තුවේ වර්ගය සහ වස්තුව තුළ ගබඩා කර ඇති දත්ත වර්ග ඇතුළත් බයිට් අනුක්‍රමයක් ලෙස නිරූපණය කළ හැකිය.

අනුක්‍රමික වස්තුවක් ගොනුවකට ලිවීමෙන් පසුව, එය ගොනුවෙන් කියවා ඩෙසියලයිස් කළ හැකිය, එනම් වස්තුව සහ එහි දත්ත නියෝජනය කරන තොරතුරු සහ බයිට් වර්ග මතකයෙන් වස්තුව ප්‍රතිනිර්මාණය කිරීමට භාවිතා කළ හැකිය.

ඔබට මෙම සබැඳිය යොමු කිරීම සඳහා නිබන්ධනයක් අවශ්‍ය නම්

http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html

වෙනත් පන්ති වල විචල්‍යය ලබා ගන්න

D. පොදු උපයෝගිතා

ඔබේ ව්‍යාපෘතියේ ඔබට නිතර අවශ්‍ය වන පොදු දත්ත අඩංගු විය හැකි පංතියක් ඔබට තනිවම කළ හැකිය.

නියැදිය

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. අභිප්‍රායන් හරහා දත්ත සම්ප්‍රේෂණය කිරීම

දත්ත සම්ප්‍රේෂණය කිරීමේ මෙම විකල්පය සඳහා කරුණාකර මෙම නිබන්ධනය වෙත යොමු වන්න.

http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/

මෙය සිදු කිරීම සඳහා ඔබට Android BUNDLE භාවිතා කළ හැකිය.

ඔබේ පන්තියෙන් මිටියක් සාදන්න:

public Bundle toBundle() {
    Bundle b = new Bundle();
    b.putString("SomeKey", "SomeValue");

    return b;
}

ඉන්පසු මෙම බණ්ඩලය INTENT සමඟ සම්මත කරන්න. දැන් ඔබට ඔබේ පන්ති වස්තුව ප්‍රතිනිර්මාණය කළ හැකිය

public CustomClass(Context _context, Bundle b) {
    context = _context;
    classMember = b.getString("SomeKey");
}

මෙය ඔබගේ අභිරුචි පන්තියේ ප්‍රකාශ කර භාවිතා කරන්න.

පාර්සල් කළ හැකි උදව්වට ස්තූතියි, නමුත් මම තවත් විකල්ප විසඳුමක් සොයා ගතිමි

 public class getsetclass implements Serializable {
        private int dt = 10;
    //pass any object, drwabale 
        public int getDt() {
            return dt;
        }

        public void setDt(int dt) {
            this.dt = dt;
        }
    }

ක්‍රියාකාරකමෙන්

getsetclass d = new getsetclass ();
                d.setDt(50);
                LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
                obj.put("hashmapkey", d);
            Intent inew = new Intent(SgParceLableSampelActivity.this,
                    ActivityNext.class);
            Bundle b = new Bundle();
            b.putSerializable("bundleobj", obj);
            inew.putExtras(b);
            startActivity(inew);

ක්‍රියාකාරකම් 2 හි දත්ත ලබා ගන්න

 try {  setContentView(R.layout.main);
            Bundle bn = new Bundle();
            bn = getIntent().getExtras();
            HashMap<String, Object> getobj = new HashMap<String, Object>();
            getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
            getsetclass  d = (getsetclass) getobj.get("hashmapkey");
        } catch (Exception e) {
            Log.e("Err", e.getMessage());
        }

ක්‍රියාකාරකම් අතර වස්තූන් යැවීමට මම Gson එහි ප්‍රබල හා සරල api සමඟ භාවිතා කරමි,

උදාහරණයක්

// This is the object to be sent, can be any object
public class AndroidPacket {

    public String CustomerName;

   //constructor
   public AndroidPacket(String cName){
       CustomerName = cName;
   }   
   // other fields ....


    // You can add those functions as LiveTemplate !
    public String toJson() {
        Gson gson = new Gson();
        return gson.toJson(this);
    }

    public static AndroidPacket fromJson(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, AndroidPacket.class);
    }
}

කාර්යයන් 2 ක් ඔබ යැවීමට අවශ්‍ය වස්තූන් වෙත ඒවා එකතු කරයි

භාවිතය

වස්තුව A සිට B දක්වා යවන්න

    // Convert the object to string using Gson
    AndroidPacket androidPacket = new AndroidPacket("Ahmad");
    String objAsJson = androidPacket.toJson();

    Intent intent = new Intent(A.this, B.class);
    intent.putExtra("my_obj", objAsJson);
    startActivity(intent);

බී වලින් ලබා ගන්න

@Override
protected void onCreate(Bundle savedInstanceState) {        
    Bundle bundle = getIntent().getExtras();
    String objAsJson = bundle.getString("my_obj");
    AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);

    // Here you can use your Object
    Log.d("Gson", androidPacket.CustomerName);
}

මම කරන සෑම ව්‍යාපෘතියකම පාහේ එය භාවිතා කරන අතර මට කාර්ය සාධන ගැටළු නොමැත.

මම එකම ගැටලුව සමඟ පොරබදිමි. මම එය විසඳුවේ ස්ථිතික පංතියක් භාවිතා කරමින්, මට අවශ්‍ය ඕනෑම දත්තයක් හැෂ්මැප් එකක ගබඩා කරමිනි. ඉහළින් මම සම්මත ක්‍රියාකාරකම් පන්තියේ දිගුවක් භාවිතා කරමි, එහිදී මම ක්‍රම ඉක්මවා ගොස් ඇත. දත්ත ප්‍රවාහනය සහ දත්ත නිෂ්කාශනය සැඟවීම සඳහා onDestroy නිර්මාණය කරන්න. සමහර හාස්‍යජනක සැකසුම් වෙනස් කළ යුතුය. උදා: දිශානතිය-හැසිරවීම.

ව්‍යාඛ්‍යාව: වෙනත් ක්‍රියාකාරකමකට සම්මත වස්තු ලබා නොදීම බූරුවාගේ වේදනාවයි. එය හරියට දණහිසට වෙඩි තබා මීටර් 100 ක් දිනා ගැනීමේ බලාපොරොත්තුවෙනි. "Parcable" ප්රමාණවත් ආදේශකයක් නොවේ. එය මට සිනාසෙයි ... මගේ තාක්‍ෂණයෙන් තොර ඒපීඅයි වෙත මෙම අතුරුමුහුණත ක්‍රියාත්මක කිරීමට මට අවශ්‍ය නැත, නව ස්ථරයක් හඳුන්වා දීමට මට අවශ්‍ය තරම් අඩුය ... එය කෙසේ විය හැකිද, අප ජංගම වැඩසටහන් වල දුරින් සිටින බව නූතන ආදර්ශය ...

ඔබගේ පළමු ක්‍රියාකාරකම තුළ:

intent.putExtra("myTag", yourObject);

ඔබේ දෙවැන්න තුළ:

myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");

ඔබේ අභිරුචි වස්තුව අනුක්‍රමික කිරීමට අමතක නොකරන්න:

public class myCustomObject implements Serializable {
...
}

මෙය කළ හැකි තවත් ක්‍රමයක් නම් Applicationවස්තුව භාවිතා කිරීමයි (android.app.Application). ඔබ මෙය ඔබගේ AndroidManifest.xmlගොනුවේ අර්ථ දක්වන්නේ :

<application
    android:name=".MyApplication"
    ...

ඔබට ඕනෑම ක්‍රියාකාරකමකින් මෙය අමතා වස්තුව Applicationපන්තියට සුරැකිය හැක .

පළමු ක්‍රියාකාරකම තුළ:

MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);

දෙවන ක්‍රියාකාරිත්වයේ දී, කරන්න:

MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);

ඔබට යෙදුම් මට්ටමේ විෂය පථයක් ඇති වස්තූන් තිබේ නම් මෙය පහසුය, එනම් ඒවා යෙදුම පුරාම භාවිතා කළ යුතුය. එමParcelable ඔබ වස්තුව විෂය පථය පුරා හෝ විෂය පථය සීමා කළ හැකි නම් පැහැදිලි පාලනය අවශ්ය නම් ක්රමය තවමත් හොඳයි.

මෙය Intentsසම්පූර්ණයෙන්ම භාවිතා කිරීමෙන් වැළකී සිටියි . ඔවුන් ඔබට ගැලපේදැයි මම නොදනිමි. මා මෙය භාවිතා කළ තවත් ක්‍රමයක් නම් int, වස්තූන් හදුනාගැනීම් අභිප්‍රායන් හරහා යවා මා සිතියම්වල ඇති Applicationවස්තූන් ලබා ගැනීමයි .

ඔබේ පන්ති ආකෘතියේ (වස්තුව) අනුක්‍රමිකව ක්‍රියාත්මක කරන්න, උදාහරණයක් ලෙස:

public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

    public void setIdProveedor(int idProveedor) {
        this.idProveedor = idProveedor;
    }


}

සහ ඔබේ පළමු ක්‍රියාකාරකම

MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
                i.putExtra("mensajes",mp);
                startActivity(i);

සහ ඔබගේ දෙවන ක්‍රියාකාරකම (නව ක්‍රියාකාරිත්වය)

        MensajesProveedor  mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");

වාසනාව!!

public class SharedBooking implements Parcelable{

    public int account_id;
    public Double betrag;
    public Double betrag_effected;
    public int taxType;
    public int tax;
    public String postingText;

    public SharedBooking() {
        account_id = 0;
        betrag = 0.0;
        betrag_effected = 0.0;
        taxType = 0;
        tax = 0;
        postingText = "";
    }

    public SharedBooking(Parcel in) {
        account_id = in.readInt();
        betrag = in.readDouble();
        betrag_effected = in.readDouble();
        taxType = in.readInt();
        tax = in.readInt();
        postingText = in.readString();
    }

    public int getAccount_id() {
        return account_id;
    }
    public void setAccount_id(int account_id) {
        this.account_id = account_id;
    }
    public Double getBetrag() {
        return betrag;
    }
    public void setBetrag(Double betrag) {
        this.betrag = betrag;
    }
    public Double getBetrag_effected() {
        return betrag_effected;
    }
    public void setBetrag_effected(Double betrag_effected) {
        this.betrag_effected = betrag_effected;
    }
    public int getTaxType() {
        return taxType;
    }
    public void setTaxType(int taxType) {
        this.taxType = taxType;
    }
    public int getTax() {
        return tax;
    }
    public void setTax(int tax) {
        this.tax = tax;
    }
    public String getPostingText() {
        return postingText;
    }
    public void setPostingText(String postingText) {
        this.postingText = postingText;
    }
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(account_id);
        dest.writeDouble(betrag);
        dest.writeDouble(betrag_effected);
        dest.writeInt(taxType);
        dest.writeInt(tax);
        dest.writeString(postingText);

    }

    public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
    {
        public SharedBooking createFromParcel(Parcel in)
        {
            return new SharedBooking(in);
        }
        public SharedBooking[] newArray(int size)
        {
            return new SharedBooking[size];
        }
    };

}

දත්ත පසු කිරීම:

Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);

දත්ත ලබා ගැනීම:

Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");

මා සොයාගත් වඩාත්ම පහසුම විසඳුම නම් .. ස්ථිතික දත්ත සාමාජිකයන් සමඟ ගැටර්ස් සෙටර්ස් සමඟ පන්තියක් නිර්මාණය කිරීමයි.

එක් ක්‍රියාකාරකමකින් සකසා වෙනත් ක්‍රියාකාරකමකින් එම වස්තුව ලබා ගන්න.

ක්‍රියාකාරකම් A.

mytestclass.staticfunctionSet("","",""..etc.);

ක්‍රියාකාරකම් b

mytestclass obj= mytestclass.staticfunctionGet();

ඔබේ පන්ති වර්ගයේ වස්තූන් පසුකර ගැනීමට සහ ලබා ගැනීමට ඔබට putExtra (Serializable ..) සහ getSerializableExtra () ක්‍රම භාවිතා කළ හැකිය; ඔබට ඔබේ පන්තිය අනුක්‍රමික ලෙස සලකුණු කළ යුතු අතර ඔබේ සියලුම සාමාජික විචල්‍යයන් අනුක්‍රමික කළ හැකි බවට වග බලා ගන්න ...

Android යෙදුම සාදන්න

ගොනුව >> නව >> ඇන්ඩ්‍රොයිඩ් යෙදුම

ව්‍යාපෘතියේ නම ඇතුළත් කරන්න: android-pass-object-to-activity

පැකේජ්: com.hmkcode.android

වෙනත් පෙරනිමි තේරීම් තබා ගන්න, ඔබ අවසන් වන තෙක් ඊළඟට යන්න

යෙදුම නිර්මාණය කිරීමට පෙර අපි POJO පන්තියේ “පුද්ගලයා” නිර්මාණය කළ යුතු අතර එය එක් ක්‍රියාකාරකමකින් තවත් ක්‍රියාකාරකමක් වෙත යැවීමට අපි භාවිතා කරමු. පන්තිය අනුක්‍රමික අතුරු මුහුණත ක්‍රියාත්මක කරන බව සැලකිල්ලට ගන්න.

Person.java

package com.hmkcode.android;
import java.io.Serializable;

public class Person implements Serializable{

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

        // getters & setters....

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }   
}

ක්‍රියාකාරකම් දෙකක් සඳහා පිරිසැලසුම් දෙකක්

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >

<LinearLayout
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
    <TextView
        android:id="@+id/tvName"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:gravity="center_horizontal"
        android:text="Name" />

    <EditText
        android:id="@+id/etName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"

        android:ems="10" >
        <requestFocus />
    </EditText>
</LinearLayout>

<LinearLayout
     android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
<TextView
    android:id="@+id/tvAge"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
    android:text="Age" />
<EditText
    android:id="@+id/etAge"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:ems="10" />
</LinearLayout>

<Button
    android:id="@+id/btnPassObject"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="Pass Object to Another Activity" />

</LinearLayout>

activity_another.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
 >

<TextView
    android:id="@+id/tvPerson"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
 />

</LinearLayout>

ක්‍රියාකාරකම් පන්ති දෙකක්

1) ActivityMain.java

package com.hmkcode.android;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements OnClickListener {

Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btnPassObject = (Button) findViewById(R.id.btnPassObject);
    etName = (EditText) findViewById(R.id.etName);
    etAge = (EditText) findViewById(R.id.etAge);

    btnPassObject.setOnClickListener(this);
}

@Override
public void onClick(View view) {

    // 1. create an intent pass class name or intnet action name 
    Intent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");

    // 2. create person object
    Person person = new Person();
    person.setName(etName.getText().toString());
    person.setAge(Integer.parseInt(etAge.getText().toString()));

    // 3. put person in intent data
    intent.putExtra("person", person);

    // 4. start the activity
    startActivity(intent);
}

}

2) anotherActivity.java

package com.hmkcode.android;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;

public class AnotherActivity extends Activity {

TextView tvPerson;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_another);

    // 1. get passed intent 
    Intent intent = getIntent();

    // 2. get person object from intent
    Person person = (Person) intent.getSerializableExtra("person");

    // 3. get reference to person textView 
    tvPerson = (TextView) findViewById(R.id.tvPerson);

    // 4. display name & age on textView 
    tvPerson.setText(person.toString());

}
}

ගූගල් හි Gson පුස්තකාලය භාවිතා කිරීමෙන් ඔබට වෙනත් ක්‍රියාකාරකම් වෙත වස්තුව යැවිය හැකිය. ඇත්ත වශයෙන්ම අපි වස්තුව json string ස්වරූපයෙන් පරිවර්තනය කරන්නෙමු. වෙනත් ක්‍රියාකාරකම් වෙත ගිය පසු අපි නැවත මෙවැනි වස්තුවක් බවට පරිවර්තනය කරමු

මේ වගේ බෝංචි පන්තියක් සලකා බලන්න

 public class Example {
    private int id;
    private String name;

    public Example(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

අපට උදාහරණ පන්තියේ වස්තුව සමත් විය යුතුය

Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);

කියවීම සඳහා අපි NextActivity හි ප්‍රතිලෝම මෙහෙයුම කළ යුතුය

 Example defObject=new Example(-1,null);
    //default value to return when example is not available
    String defValue= new Gson().toJson(defObject);
    String jsonString=getIntent().getExtras().getString("example",defValue);
    //passed example object
    Example exampleObject=new Gson().fromJson(jsonString,Example .class);

මෙම පරායත්තතාවය ශ්‍රේණියේ එකතු කරන්න

compile 'com.google.code.gson:gson:2.6.2'

Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);

මම දන්නවා මෙය ප්‍රමාදයි නමුත් එය ඉතා සරලයි. ඔබට කළ යුතුව ඇත්තේ ඔබේ පන්තියට අනුක්‍රමික ලෙස ක්‍රියාත්මක කිරීමට ඉඩ දීමයි

public class MyClass implements Serializable{

}

එවිට ඔබට වැනි අභිප්‍රායයකට යා හැකිය

Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);

එය ලබා ගැනීම සඳහා ඔබට සරල ඇමතුමක්

MyClass objec=(MyClass)intent.getExtra("theString");

ඔබේ ආදර්ශ ස්ථරයට දොරටුව ලෙස ක්‍රියා කරන සිංගල්ටන් පංතියක් (එෆ්එක්ස් සර්විස්) ඔබ සතුව ඇත්නම්, එම පන්තියේ විචල්‍යයක් ලබා ගන්නන් සහ සැකසුම් කරුවන් සමඟ එය විසඳිය හැකිය.

ක්‍රියාකාරකම් 1 හි:

Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);

ක්‍රියාකාරකම් 2 හි:

private Service service;
private Order order;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_quality);

    service = Service.getInstance();
    order = service.getSavedOrder();
    service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}

ක්රියාත්මකයි:

private static Service instance;

private Service()
{
    //Constructor content
}

public static Service getInstance()
{
    if(instance == null)
    {
        instance = new Service();
    }
    return instance;
}
private Order savedOrder;

public Order getSavedOrder()
{
    return savedOrder;
}

public void setSavedOrder(Order order)
{
    this.savedOrder = order;
}

මෙම විසඳුමට කිසිදු වස්තුවක අනුක්‍රමිකකරණය හෝ වෙනත් "ඇසුරුම්" අවශ්‍ය නොවේ. නමුත් එය ප්‍රයෝජනවත් වන්නේ ඔබ කෙසේ හෝ මේ ආකාරයේ ගෘහ නිර්මාණ ශිල්පයක් භාවිතා කරන්නේ නම් පමණි.

වස්තූන් පාර්සල් කිරීම සඳහා IMHO පහසුම ක්‍රමයයි. ඔබ පාර්සල් කළ හැකි වස්තුවට ඉහළින් විවරණ සටහනක් එක් කරන්න.

පුස්තකාලයෙන් උදාහරණයක් https://github.com/johncarl81/parceler

@Parcel
public class Example {
    String name;
    int age;

    public Example(){ /*Required empty bean constructor*/ }

    public Example(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() { return name; }

    public int getAge() { return age; }
}

පළමුව ඔබේ පන්තියේ පාර්සල් කළ හැකි දේ ක්‍රියාත්මක කරන්න. ඉන්පසු මේ ආකාරයට වස්තුව පසු කරන්න.

SendActivity.java

ObjectA obj = new ObjectA();

// Set values etc.

Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

startActivity(i);

ReceiveActivity.java

Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");

පැකේජ නූල අවශ්‍ය නොවේ, ක්‍රියාකාරකම් දෙකෙහිම නූල එක හා සමාන විය යුතුය

යොමු කිරීම

මෙම ක්‍රියාකාරකමෙන් තවත් ක්‍රියාකාරකමක් ආරම්භ කරන්න

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

වෙනත් ක්‍රියාකාරකමක් ලබා ගන්න (ඔබේ ක්‍රියාකාරිත්වය)

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

සරල ආකාරයේ දත්ත වර්ග සඳහා මෙය හරි ය. නමුත් ඔබට ක්‍රියාකාරකම් අතර සංකීර්ණ දත්ත යැවීමට අවශ්‍ය නම් එය පළමුව අනුක්‍රමිකකරණය කළ යුතුය.

මෙන්න අපට සේවක ආකෘතියක් ඇත

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

    getters...
    setters...
}

මෙවැනි සංකීර්ණ දත්ත අනුක්‍රමික කිරීම සඳහා ඔබට ගූගල් විසින් සපයන ලද Gson lib භාවිතා කළ හැකිය

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

කොල්ටින් වල

ඔබේ build.gradle හි කොට්ලින් දිගුව එක් කරන්න.

apply plugin: 'kotlin-android-extensions'

android {
    androidExtensions {
        experimental = true
   }
}

ඉන්පසු ඔබේ දත්ත පන්තිය මේ ආකාරයට සාදන්න.

@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable

වස්තුව අභිප්‍රාය සමඟ සමත් වන්න

val sample = Sample(1,"naveen")

val intent = Intent(context, YourActivity::class.java)
    intent.putExtra("id", sample)
    startActivity(intent)

චේතනාවෙන් වස්තුව ලබා ගන්න

val sample = intent.getParcelableExtra("id")

පහසුම හා ජාවා කිරීමේ ක්‍රමය නම්: ඔබේ පූජෝ / ආදර්ශ පන්තියේ අනුක්‍රමිකව ක්‍රියාත්මක කරන්න

කාර්ය සාධනය බැලීම සඳහා ඇන්ඩ්‍රොයිඩ් සඳහා නිර්දේශිතයි: ආකෘති පාර්සල් කළ හැකි කරන්න

ඔබ putExtra විශේෂාංගය භාවිතා කිරීම ගැන විශේෂ අවධානයක් යොමු නොකරන්නේ නම් සහ වස්තූන් සමඟ වෙනත් ක්‍රියාකාරකමක් දියත් කිරීමට අවශ්‍ය නම්, ඔබට GNLauncher පරීක්ෂා කළ හැකිය ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher උත්සාහයක් ලෙස මා විසින් ලියන ) පුස්තකාලය මෙම ක්‍රියාවලිය වඩාත් forward ජුව ඉදිරියට ගෙන යාමට.

GNLauncher වෙනත් ක්‍රියාකාරකමකින් ක්‍රියාකාරකමකට වස්තු / දත්ත යැවීම පහසු කරයි. එය වර්ගයේ ආරක්ෂාව හඳුන්වා දෙන අතර අනුක්‍රමික වීමට ඇති සියලු කරදර ඉවත් කරයි, නූල් යතුරු භාවිතා කිරීමේ අභිප්‍රාය අමුණන්න සහ අනෙක් කෙළවරේ එය අහෝසි කරන්න.