new - start activity from another activity android




Come inviare un oggetto da un'attività Android a un'altra utilizzando Intenti? (20)

Come posso passare un oggetto di un tipo personalizzato da un'attività a un'altra utilizzando il metodo putExtra() della classe Intent ?


È possibile inviare oggetti serializzabili tramite l'intento

// 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 {
} 

È possibile utilizzare Android BUNDLE per farlo.

Crea un pacchetto dalla tua classe come:

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

    return b;
}

Quindi passa questo pacchetto con INTENT. Ora puoi ricreare il tuo oggetto di classe passando il bundle come

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

Dichiaralo nella tua classe personalizzata e usalo.


Crea un'applicazione Android

File >> Nuovo >> Applicazione Android

Inserisci il nome del progetto: android-pass-object-to-activity

Pakcage: com.hmkcode.android

Mantieni le altre selezioni defive, vai Avanti fino a raggiungere Finish

Prima di iniziare a creare l'app, dobbiamo creare la classe POJO "Persona" che useremo per inviare l'oggetto da un'attività all'altra. Si noti che la classe sta implementando un'interfaccia serializzabile.

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

Due layout per due attività

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>

Due classi di attività

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

}
}

Dovrai serializzare il tuo oggetto in una sorta di rappresentazione di stringhe. Una possibile rappresentazione di stringa è JSON, e uno dei modi più semplici per serializzare su / da JSON in Android, se me lo chiedi, è attraverso Google GSON .

In tal caso basta inserire il valore di restituzione della stringa da (new Gson()).toJson(myObject); e recupera il valore della stringa e usa fromJson per tornare indietro nel tuo oggetto.

Se il tuo oggetto non è molto complesso, tuttavia, potrebbe non valere la pena di sovraccarico, e potresti prendere in considerazione di passare invece i valori separati dell'oggetto.


Ho faticato con lo stesso problema. L'ho risolto usando una classe statica, memorizzando tutti i dati che voglio in una HashMap. In cima utilizzo un'estensione della classe di attività standard in cui ho annullato i metodi suCreare un onDestroy per eseguire il trasporto dei dati e la cancellazione dei dati nascosti. Alcune impostazioni ridicole devono essere modificate, ad esempio la gestione dell'orientamento.

Annotazione: non fornire oggetti generali da passare a un'altra attività è un rompicoglioni. È come spararsi al ginocchio e sperare di vincere 100 metri. "Parcable" non è un sostituto sufficiente. Mi fa ridere ... Non voglio implementare questa interfaccia con la mia API senza tecnologia, perché meno voglio introdurre un nuovo Layer ... Come potrebbe essere, che siamo in una programmazione mobile così lontana da paradigma moderno ...


La tua classe dovrebbe implementare Serializable o Parcelable.

public class MY_CLASS implements Serializable

Una volta fatto puoi inviare un oggetto su putExtra

intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

Per ottenere degli extra devi solo farlo

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

Se la tua classe implementa Parcelable use next

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

Spero che aiuti: D


Per situazioni in cui sai che passerai dati all'interno di un'applicazione, usa "globals" (come le classi statiche)

Here cosa ha detto Dianne Hackborn (hackbod, un ingegnere del software Android di Google) in materia:

Per le situazioni in cui sai che le attività sono in esecuzione nello stesso processo, puoi semplicemente condividere i dati tramite globals. Ad esempio, potresti avere una HashMap<String, WeakReference<MyInterpreterState>> globale HashMap<String, WeakReference<MyInterpreterState>> e quando crei un nuovo MyInterpreterState, ottieni un nome univoco per esso e inseriscilo nella mappa hash; per inviare tale stato a un'altra attività, è sufficiente inserire il nome univoco nella mappa hash e quando viene avviata la seconda attività, è possibile recuperare MyInterpreterState dalla mappa hash con il nome che riceve.


Risposta breve per necessità veloci

1. Implementa la tua classe in serializzabile.

Se hai classi interiori non dimenticarti di implementarle anche in Serializable !!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2. Metti il ​​tuo oggetto in Intento

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

3. E ricevi il tuo oggetto nell'altra classe di attività

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

Un altro modo per farlo è utilizzare l'oggetto Application (android.app.Application). Lo definisci nel tuo file AndroidManifest.xml come:

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

È quindi possibile chiamare questo da qualsiasi attività e salvare l'oggetto nella classe Application .

In FirstActivity:

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

In SecondActivity, fai:

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

Questo è utile se si dispone di oggetti con ambito a livello di applicazione, ovvero devono essere utilizzati in tutta l'applicazione. Il metodo Parcelable è ancora migliore se si desidera il controllo esplicito sull'ambito dell'oggetto o se l'ambito è limitato.

Questo però evita completamente l'uso di Intents . Non so se ti stanno bene. Un altro modo in cui ho usato questo è quello di avere identificativi int degli oggetti inviati attraverso intenti e recuperare oggetti che ho in Maps nell'oggetto Application .


Uso Gson con la sua così potente e semplice API per inviare oggetti tra le attività,

Esempio

// 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 funzioni li aggiungi agli oggetti che vuoi inviare

uso

Invia oggetto da A 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);

Ricevi in ​​B

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

Lo uso quasi in ogni progetto che faccio e non ho problemi di prestazioni.


la soluzione più semplice che ho trovato è .. creare una classe con membri di dati statici con getter setter.

impostare da un'attività e ottenere da un'altra attività quell'oggetto.

attività A

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

attività b

mytestclass obj= mytestclass.staticfunctionGet();

nel modello di classe (Object) implementare Serializable, ad esempio:

public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

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


}

e la tua prima attività

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

e la tua seconda attività (NewActivity)

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

in bocca al lupo!!


se la classe dell'oggetto implementa Serializable , non è necessario fare altro, è possibile passare un oggetto serializzabile.
questo è quello che uso.


Avvia un'altra attività da questi parametri del pass di attività tramite Bundle Object

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

Recupera su un'altra attività (YourActivity)

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

Questo è ok per il tipo di dati di tipo semplice. Ma se vuoi passare dati complessi tra un'attività devi prima serializzarla.

Qui abbiamo il modello dei dipendenti

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

    getters...
    setters...
}

Puoi usare Gson lib fornito da google per serializzare i dati complessi come questo

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

Se hai una classe singleton (fx Service) che funge comunque da gateway per il tuo livello del modello, può essere risolta avendo una variabile in quella classe con getter e setter per essa.

Nell'attività 1:

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

Nell'attività 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.
}

In servizio:

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

Questa soluzione non richiede alcuna serializzazione o altro "packaging" dell'oggetto in questione. Ma sarà utile solo se stai usando questo tipo di architettura comunque.


So che è tardi, ma è molto semplice. Tutto quello che devi fare è lasciare che la tua classe implementa come Serializable

public class MyClass implements Serializable{

}

allora puoi passare a un intento come

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

Per ottenerlo basta chiamare

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

Di gran lunga il modo più semplice per ordinare oggetti. Devi solo aggiungere un tag di annotazione sopra l'oggetto che desideri renderlo parcelable.

Un esempio dalla libreria è sotto 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; }
}

POJO class "Post " (nota che è implementato serializzabile)

package com.example.booklib;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import android.graphics.Bitmap;

public class Post implements Serializable{
    public String message;
    public String bitmap;
    List<Comment> commentList = new ArrayList<Comment>();
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String getBitmap() {
        return bitmap;
    }
    public void setBitmap(String bitmap) {
        this.bitmap = bitmap;
    }
    public List<Comment> getCommentList() {
        return commentList;
    }
    public void setCommentList(List<Comment> commentList) {
        this.commentList = commentList;
    }

}

POJO class "Comment" (Essendo un membro della classe Post, è anche necessario implementare il Serializable)

    package com.example.booklib;

    import java.io.Serializable;

    public class Comment implements Serializable{
        public String message;
        public String fromName;
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
        public String getFromName() {
            return fromName;
        }
        public void setFromName(String fromName) {
            this.fromName = fromName;
        }

    }

Quindi nella tua classe di attività, puoi fare quanto segue per passare l'oggetto a un'altra attività.

ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
        @Override
        public void onItemClick(AdapterView<?> parent, View view,
                int position, long id) {
            Post item = (Post)parent.getItemAtPosition(position);
            Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
            intent.putExtra("post",item);
            startActivity(intent);

        }
    });

Nella classe del destinatario "CommentiAttività" è possibile ottenere i dati come segue

Post post =(Post)getIntent().getSerializableExtra("post");

Se non si è particolarmente interessati all'utilizzo della funzione putExtra e si desidera semplicemente avviare un'altra attività con gli oggetti, è possibile controllare la libreria GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) che ho scritto in un tentativo per rendere questo processo più semplice.

GNLauncher rende l'invio di oggetti / dati a un'attività da un'altra attività ecc. Facile come chiamare una funzione nell'attività con i dati richiesti come parametri. Introduce la sicurezza del tipo e rimuove tutti i problemi di dover serializzare, attaccare all'intento utilizzando chiavi di stringa e annullare l'operazione all'altra estremità.


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




android-activity