java titledborder - Wie übertrage ich ein Objekt von einer Aktivität auf eine andere auf Android?




jpanel lineborder (25)

Ich versuche, ein Objekt meiner Kundenklasse aus einer Activity zu senden und es in einer anderen Activity anzuzeigen.

Der Code für die Kundenklasse:

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

Ich möchte sein Objekt von einer Activity zur anderen senden und dann die Daten der anderen Activity anzeigen.

Wie kann ich das erreichen?


Answers

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.


Ich habe eine Singleton-Hilfsklasse erstellt, die temporäre Objekte enthält.

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

Verwenden Sie IntentHelper nicht, um Ihre Objekte in Intent zu setzen:

IntentHelper.addObjectForKey(obj, "key");

In Ihrer neuen Aktivität können Sie das Objekt erhalten:

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

Beachten Sie, dass das Objekt nach dem Laden entfernt wird, um unnötige Referenzen zu vermeiden.


Der beste Weg ist, eine Klasse zu haben (nennen Sie es Control) in Ihrer Anwendung, die eine statische Variable vom Typ 'Kunde' (in Ihrem Fall) enthält. Initialisiere die Variable in deiner Aktivität A.

Beispielsweise:

Control.Customer = CustomerClass;

Gehe dann zu Aktivität B und hole sie von der Control-Klasse. Vergessen Sie nicht, nach der Verwendung der Variablen eine Null zuzuweisen, da andernfalls der Speicher verschwendet wird.


  • Die Verwendung von globalen statischen Variablen ist keine gute Software-Engineering- Praxis.
  • Das Konvertieren der Felder eines Objekts in primitive Datentypen kann ein hektischer Job sein .
  • Serializable ist in Ordnung, aber auf der Android-Plattform ist es nicht leistungsfähig .
  • Parcelable ist speziell für Android entwickelt und Sie sollten es verwenden. Hier ein einfaches Beispiel: Übergeben benutzerdefinierter Objekte zwischen Android-Aktivitäten

Sie können über diese site Parcelable-Code für Ihre Klasse generieren.


Ich verwende Parcelable, um Daten von einer Aktivität an eine andere zu senden. Hier ist mein Code, der in meinem Projekt gut funktioniert.

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

In activityA verwende es so:

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

In ActivityB verwende es so, um Daten zu erhalten:

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

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

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
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);

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.

Verwendung

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.


Sie können die Daten des Objekts auch in temporäre Strings und Ints schreiben und sie an die Aktivität übergeben. Auf diese Weise erhalten Sie zwar die Daten, nicht aber das Objekt selbst.

Aber wenn Sie sie nur anzeigen möchten und das Objekt nicht in einer anderen Methode oder ähnlichem verwenden, sollte es ausreichen. Ich habe es auf die gleiche Weise gemacht, um nur Daten von einem Objekt in einer anderen Aktivität anzuzeigen.

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

Sie könnten sie auch direkt anstelle der Temp Ivars weitergeben, aber auf diese Weise ist es meiner Meinung nach klarer. Darüber hinaus können Sie die temporären Elemente auf null festlegen, damit sie früher von dem GarbageCollector bereinigt werden.

Viel Glück!

Nebenbei bemerkt: überschreiben Sie toString (), anstatt Ihre eigene Druckmethode zu schreiben.

Wie in den folgenden Kommentaren erwähnt, erhalten Sie so Ihre Daten in einer anderen Aktivität zurück:

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

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


Wenn Sie sich für Samuh entscheiden, denken Sie daran, dass nur primitive Werte gesendet werden können. Das heißt, Werte, die parcable sind. Wenn Ihr Objekt also komplexe Objekte enthält, werden diese nicht folgen. Zum Beispiel, Variablen wie Bitmap, HashMap etc ... Diese sind schwierig, um die Absicht zu übergeben.

Im Allgemeinen würde ich Ihnen raten, nur primitive Datentypen als Extras zu senden, wie String, int, boolean usw. In Ihrem Fall wäre es: String fname , String lname , int age und String address .

Meine Meinung: Komplexere Objekte werden besser geteilt, wenn ein ContentProvider , SDCard , etc. implementiert wird. Es ist auch möglich, eine statische Variable zu verwenden , dies kann jedoch schnell zu fehleranfälligem Code führen ...

Aber wieder ist es nur meine subjektive Meinung.


Sie können versuchen, diese Klasse zu verwenden. Die Einschränkung besteht darin, dass sie nicht außerhalb eines Prozesses verwendet werden kann.

Eine Aktivität:

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

Andere Aktivität:

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

We can pass the object from one activity to another activity:

SupplierDetails poSuppliersDetails = new SupplierDetails();

Inside poSuppliersDetails we have some values. Now I am sending this object to target activity:

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

How to get this in ACtivityTwo:

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

Implementieren Sie Ihre Klasse mit Serializable. Nehmen wir an, dass dies Ihre Entitätsklasse ist:

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

Wir senden das Objekt namens dene von X-Aktivität an Y-Aktivität. Irgendwo in X-Aktivität;

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

In Y-Aktivität erhalten wir das Objekt.

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

Das ist es.


Pass object from one activity to another activity.

(1) source activity

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

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

(2) destination acitivity

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

This question is also discussed in another question. Please have a look at a solution to Passing data through intent using Serializable . The main point is about using Bundle object which stores the necessary data inside Intent .

 Bundle bundle = new Bundle();

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

 intent.putExtras(bundle);

To extract values:

 Bundle bundle = new Bundle();

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

Advantage of Serializable is its simplicity. However, you should consider using Parcelable method if you need many data to be transferred, because Parcelable is specifically designed for Android and it is more efficient than Serializable . You can create Parcelable class using:

  1. an online tool - site
  2. a plugin for Android Studio - Android Parcelable code generator

Ich habe eine einfache und elegante Methode gefunden:

  • Nein Parcelable
  • Nein Serialisierbar
  • Kein statisches Feld
  • Kein Ereignis Bus

Methode 1

Code für die erste Aktivität:

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

Code für die zweite Aktivität:

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

Sie finden objSent & objReceived haben den gleichen hashCode , also sind sie identisch.

Aber warum können wir auf diese Weise ein Java-Objekt übergeben?

Eigentlich wird Android-Binder globale JNI-Referenz für Java-Objekt erstellen und diese globale JNI-Referenz freigeben, wenn keine Referenz für dieses Java-Objekt vorhanden ist. Binder speichert diese globale JNI-Referenz im Binder-Objekt.

* ACHTUNG: Diese Methode funktioniert nur, wenn die beiden Aktivitäten im selben Prozess ausgeführt werden, andernfalls werfen Sie ClassCastException an (ObjectWrapperForBinder) getIntent (). GetExtras (). GetBinder ("object_value") *

Klasse ObjectWrapperForBinder-Definition

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

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

    public Object getData() {
        return mData;
    }
}

Methode 2

  • für den Absender,
    1. Verwenden Sie eine benutzerdefinierte native Methode, um Ihr Java-Objekt der globalen JNI-Referenztabelle hinzuzufügen (über JNIEnv :: NewGlobalRef)
    2. setze die return Integer (eigentlich JNIEnv :: NewGlobalRef return jobject, was ein Zeiger ist, können wir es sicher in int umwandeln) in deine Intent (via Intent :: putExtra)
  • für den Empfänger
    1. get integer von Intent (über Intent :: getInt)
    2. Verwenden Sie eine benutzerdefinierte native Methode zum Wiederherstellen Ihres Java-Objekts aus der globalen JNI-Referenztabelle (über JNIEnv :: NewLocalRef)
    3. Entferne das Objekt aus der globalen JNI-Referenztabelle (via JNIEnv :: DeleteGlobalRef),

Aber Methode 2 hat ein kleines, aber ernstes Problem, wenn der Empfänger das Java-Objekt nicht wiederherstellen kann (zum Beispiel eine Ausnahme vor der Wiederherstellung des Java-Objekts oder die Empfänger-Aktivität gar nicht existiert), dann wird das Java-Objekt zu einem Waisen- oder Speicherverlust, Methode 1 haben dieses Problem nicht, weil Android-Binder diese Ausnahme behandeln wird

Methode 3

Um das Java-Objekt remote aufzurufen, erstellen wir einen Datenvertrag / eine Schnittstelle, um das Java-Objekt zu beschreiben. Wir werden die aidl-Datei verwenden

IDataContract.aidl

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

Code für die erste Aktivität

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

Code für die zweite Aktivität:

Ändern Sie das android: process-Attribut in AndroidManifest.xml in einen nicht leeren Prozessnamen, um sicherzustellen, dass die zweite Aktivität in einem anderen Prozess ausgeführt wird

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

Auf diese Weise können wir eine Schnittstelle zwischen zwei Aktivitäten übergeben, obwohl sie in einem anderen Prozess ausgeführt werden, und die Schnittstellenmethode remote aufrufen

Methode 4

Methode 3 scheint nicht einfach genug zu sein, weil wir eine aidl-Schnittstelle implementieren müssen. Wenn Sie nur eine einfache Aufgabe ausführen möchten und der Rückgabewert der Methode unnötig ist, können wir android.os.Messenger verwenden

Code für die erste Aktivität (Absender):

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

Code für die zweite Aktivität (Empfänger):

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

    }
}

Alle Messenger.send werden in einem Handler asynchron und sequenziell ausgeführt.

Eigentlich ist android.os.Messenger auch eine Hilfe-Schnittstelle, wenn Sie den Android-Quellcode haben, können Sie eine Datei namens IMessenger.aidl finden

package android.os;

import android.os.Message;

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

Es gibt verschiedene Möglichkeiten, auf Variablen oder Objekte in anderen Klassen oder Aktivitäten zuzugreifen.

Eine Datenbank

B. Gemeinsame Voreinstellungen

C. Objektserialisierung

D. Eine Klasse, die gemeinsame Daten enthalten kann, kann als Common Utilities bezeichnet werden. Es hängt von dir ab.

E. Übergeben von Daten über Intents und Parcelable Interface.

Es hängt von Ihren Projektanforderungen ab.

A. Datenbank

SQLite ist eine Open-Source-Datenbank, die in Android eingebettet ist. SQLite unterstützt standardmäßige relationale Datenbankfunktionen wie SQL-Syntax, Transaktionen und vorbereitete Anweisungen.

Tutorials

B. Gemeinsame Voreinstellungen

Angenommen, Sie möchten den Benutzernamen speichern. Also gibt es jetzt zwei Dinge, einen Schlüssel- Benutzernamen, Wert Wert.

Wie zu speichern

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

Mit putString (), putBoolean (), putInt (), putFloat () und putLong () können Sie Ihren gewünschten dtatype speichern.

Wie man holt

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

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

C. Objektserialisierung

Object serlization wird verwendet, wenn wir einen Objektstatus speichern möchten, um ihn über ein Netzwerk zu senden, oder Sie können ihn auch für Ihren Zweck verwenden.

Verwenden Sie Java-Beans und speichern Sie sie als eines seiner Felder und verwenden Sie dafür Getter und Setter.

JavaBeans sind Java-Klassen mit Eigenschaften. Stellen Sie sich Eigenschaften als private Instanzvariablen vor. Da sie privat sind, können sie nur von außerhalb ihrer Klasse über Methoden in der Klasse aufgerufen werden. Die Methoden, die den Wert einer Eigenschaft ändern, werden Setter-Methoden genannt, und die Methoden, die den Wert einer Eigenschaft abrufen, werden Getter-Methoden genannt.

public class VariableStorage implements Serializable  {

    private String inString;

    public String getInString() {
        return inString;
    }

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

Setzen Sie die Variable in Ihrer Mail-Methode mit

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

Verwenden Sie dann die Objekt-Serialisierung, um dieses Objekt zu serialisieren und in der anderen Klasse dieses Objekt zu deserialisieren.

In der Serialisierung kann ein Objekt als eine Sequenz von Bytes dargestellt werden, die die Daten des Objekts sowie Informationen über den Typ des Objekts und die Arten von Daten enthält, die in dem Objekt gespeichert sind.

Nachdem ein serialisiertes Objekt in eine Datei geschrieben wurde, kann es aus der Datei gelesen und deserialisiert werden. Das heißt, die Typinformationen und Bytes, die das Objekt und seine Daten darstellen, können verwendet werden, um das Objekt im Speicher neu zu erstellen.

Wenn Sie Tutorial für diese möchten, beziehen Sie sich auf:

D. CommonUtilities

Sie können selbst eine Klasse erstellen, die gemeinsame Daten enthalten kann, die Sie häufig in Ihrem Projekt benötigen.

Probe

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. Übergeben von Daten über Absichten

Bitte lesen Sie das Tutorial Android - Parcel-Daten, um zwischen Aktivitäten mit Parcelable-Klassen für diese Möglichkeit der Datenweitergabe zu wechseln .


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

Eine Option könnte sein, Ihre benutzerdefinierte Klasse die Serializable Schnittstelle implementieren zu lassen, und dann können Sie Objektinstanzen in der Absicht extra übergeben, indem Sie die putExtra(Serializable..) -Variante der Intent#putExtra() -Methode verwenden.

Pseudocode :

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

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

Beim Anrufen einer Aktivität

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

In toClass.java erhalten Sie die Aktivität von

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

Stellen Sie sicher, dass die Kundenklasse parcelable implementiert

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

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.


Erstellen Sie Ihre eigene Klasse Customer wie folgt:

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

}

In Ihrer onCrate() Methode

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

In der xyz activity Sie folgenden Code verwenden:

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

Yeah, using a static object is by far the easiest way of doing this with custom non-serialisable objects.


Verwenden Sie gson , um Ihr Objekt in JSON zu konvertieren und es durch Absicht zu übergeben. Konvertiere den JSON in der neuen Aktivität in ein Objekt.

Beispiel:

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

Und in deiner nächsten Aktivität, wo du ein Objekt übergeben willst:

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

Versuchen Sie, Ihr Antivirus zu deaktivieren. Vielleicht macht es den Emulator etwas schneller.





java android object android-intent android-activity