with - menu android html




Come posso passare i dati tra le attività nell'applicazione Android? (20)

Risposta supplementare: convenzioni di denominazione per la stringa di chiavi

Il processo effettivo di trasmissione dei dati è già stato risolto, tuttavia la maggior parte delle risposte utilizza stringhe codificate per il nome della chiave nell'intento. Di solito questo va bene se usato solo all'interno della tua app. Tuttavia, la documentazione raccomanda l' uso delle costanti EXTRA_* per tipi di dati standardizzati.

Esempio 1: utilizzo Intent.EXTRA_* tasti Intent.EXTRA_*

Prima attività

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);

Seconda attività:

Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);

Esempio 2: definizione della propria chiave static final

Se una delle stringhe Intent.EXTRA_* non soddisfa i tuoi bisogni, puoi definirne la tua all'inizio della prima attività.

static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";

Includere il nome del pacchetto è solo una convenzione se stai usando la chiave solo nella tua app. Ma è una necessità evitare i conflitti di denominazione se stai creando un tipo di servizio che altre app possono chiamare con un Intento.

Prima attività:

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);

Seconda attività:

Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);

Esempio 3: utilizzo di una chiave di risorsa String

Sebbene non menzionata nella documentazione, questa risposta consiglia l'uso di una risorsa String per evitare le dipendenze tra le attività.

strings.xml

 <string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>

Prima attività

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);

Seconda attività

Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));

Ho uno scenario in cui, dopo aver effettuato l'accesso tramite una pagina di accesso, ci sarà un button disconnessione su ogni activity .

Quando si fa clic sign-out , passerò l' session id della session id dell'utente che ha eseguito l'accesso per uscire. Qualcuno può guidarmi su come mantenere l' session id disponibile per tutte le activities ?

Qualsiasi alternativa a questo caso


È possibile inviare dati tra attività utilizzando l'oggetto intent. Considera che hai due attività: FirstActivity e SecondActivity .

Inside FirstActivity:

Utilizzo di Intent:

i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

Ora è possibile utilizzare diversi metodi di classe bundle per ottenere i valori passati da FirstActivity per Key.

Ad esempio bundle.getString("key") , bundle.getDouble("key") , bundle.getInt("key") ecc.


Classe di origine:

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)

Classe di destinazione (classe NewActivity):

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.view);

    Intent intent = getIntent();

    String fName = intent.getStringExtra("firstName");
    String lName = intent.getStringExtra("lastName");
}

Devi solo inviare degli extra mentre chiami il tuo intento.

Come questo:

Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

Ora sul metodo OnCreate di SecondActivity puoi recuperare gli extra in questo modo.

Se il valore che hai inviato era long :

long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));

Se il valore che hai inviato era una String :

String value = getIntent().getStringExtra("Variable name which you sent as an extra");

Se il valore che hai inviato era un Boolean :

Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);

Gli extra di Passing Intent sono un buon approccio, come ha notato Erich.

L'oggetto Application è comunque un altro modo, ed è a volte più facile quando si ha a che fare con lo stesso stato su più attività (invece di doverlo / metterlo ovunque), o oggetti più complessi di primitive e stringhe.

È possibile estendere l'applicazione, quindi impostare / ottenere ciò che si desidera e accedere da qualsiasi attività (nella stessa applicazione) con getApplication() .

Inoltre, tieni presente che altri approcci che potresti vedere, come la statica, possono essere problematici perché possono portare a perdite di memoria . L'applicazione aiuta a risolvere anche questo.


Il modo più comodo per passare i dati tra le attività consiste nel passare intenti. Nella prima attività da cui si desidera inviare i dati, è necessario aggiungere il codice,

String str = "My Data"; //Data you want to send
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.putExtra("name",str); //Here you will add the data into intent to pass bw activites
v.getContext().startActivity(intent);

Dovresti anche importare

import android.content.Intent;

Quindi nel prossimo Acitvity (SecondActivity), è necessario recuperare i dati dall'intento utilizzando il seguente codice.

String name = this.getIntent().getStringExtra("name");

Il passaggio di dati tra le attività è principalmente tramite un oggetto intent.

Innanzitutto devi allegare i dati all'oggetto intent con l'uso della classe Bundle . Quindi chiamare l'attività utilizzando i metodi startActivity() o startActivityForResult() .

Puoi trovare ulteriori informazioni a riguardo, con un esempio tratto dal post del blog Passare dati a un'attività .


L'approccio standard.

Intent i = new Intent(this, ActivityTwo.class);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
String getrec=textView.getText().toString();
Bundle bundle = new Bundle();
bundle.putString(“stuff”, getrec);
i.putExtras(bundle);
startActivity(i);

Ora nella tua seconda attività recupera i tuoi dati dal pacchetto:

Ottieni il pacchetto

Bundle bundle = getIntent().getExtras();

Estrai i dati ...

String stuff = bundle.getString(“stuff”); 

Nella tua attività corrente, crea un nuovo Intent :

String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);    
i.putExtra("key",value);
startActivity(i);

Quindi, nella nuova attività, recupera quei valori:

Bundle extras = getIntent().getExtras();
if (extras != null) {
    String value = extras.getString("key");
    //The key argument here must match that used in the other activity
}

Usa questa tecnica per passare le variabili da un'attività all'altra.


Nota aggiornata che avevo menzionato l'uso di SharedPreference . Ha una semplice API ed è accessibile attraverso le attività di un'applicazione. Ma questa è una soluzione goffa, ed è un rischio per la sicurezza se si passano dati sensibili. È meglio usare intenti. Ha una vasta lista di metodi sovraccaricati che possono essere utilizzati per trasferire meglio molti tipi di dati diversi tra le attività. intent.putExtra un'occhiata a intent.putExtra . Questo link presenta l'uso di putExtra abbastanza bene.

Nel passaggio di dati tra le attività, il mio approccio preferito è quello di creare un metodo statico per l'attività rilevante che includa i parametri richiesti per lanciare l'intento. Che quindi fornisce facilmente l'impostazione e il recupero dei parametri. Quindi può assomigliare a questo

public class MyActivity extends Activity {
    public static final String ARG_PARAM1 = "arg_param1";
...
public static getIntent(Activity from, String param1, Long param2...) {
    Intent intent = new Intent(from, MyActivity.class);
        intent.putExtra(ARG_PARAM1, param1);
        intent.putExtra(ARG_PARAM2, param2);
        return intent;
}

....
// Use it like this.
startActivity(MyActvitiy.getIntent(FromActivity.this, varA, varB, ...));
...

Quindi è possibile creare un intento per l'attività prevista e assicurarsi di disporre di tutti i parametri. Puoi adattarti per i frammenti a. Un semplice esempio sopra, ma tu hai l'idea.


Prova questo:

CurrentActivity.java

Intent intent = new Intent(currentActivity.this, TargetActivity.class);
intent.putExtra("booktype", "favourate");
startActivity(intent);

TargetActivity.java

Bundle b = getIntent().getExtras();
String typesofbook = b.getString("booktype");

Puoi anche passare oggetti di classe personalizzati creando una classe parcelable . Il modo migliore per renderlo parcelable è scrivere la tua classe e poi semplicemente incollarla in un sito come http://www.parcelabler.com/ . Clicca su build e otterrai il nuovo codice. Copia tutto questo e sostituisci il contenuto originale della lezione. Poi-

Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);

e ottenere il risultato in NextActivity come-

Foo foo = getIntent().getExtras().getParcelable("foo");

Ora puoi semplicemente usare l'oggetto foo come avresti usato.


Puoi usare Intent

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

Un altro modo potrebbe essere l'utilizzo del modello singleton anche:

public class DataHolder {

 private static DataHolder dataHolder;
 private List<Model> dataList;

 public void setDataList(List<Model>dataList) {
    this.dataList = dataList;
 }

 public List<Model> getDataList() {
    return dataList;
 }

 public synchronized static DataHolder getInstance() {
    if (dataHolder == null) {
       dataHolder = new DataHolder();
    }
    return dataHolder;
 }
}

Dalla tua FirstActivity

private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);

Su SecondActivity

private List<Model> dataList = DataHolder.getInstance().getDataList();

Puoi usare SharedPreferences ...

  1. Registrazione. ID di sessione SharedPreferences in SharedPreferences

    SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
    Editor editor = preferences.edit();
    editor.putString("sessionId", sessionId);
    editor.commit();
    
  2. Disconnessione. Tempo di recupero dell'ID di sessione in sharedpreferences

    SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE);
    String sessionId = preferences.getString("sessionId", null);
    

Se non hai l'ID di sessione richiesto, quindi rimuovi sharedpreferences:

SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();

È molto utile, perché una volta si salva il valore e si recupera in qualsiasi punto dell'attività.


Uso i campi statici in una classe e li ottengo / li imposto:

Piace:

public class Info
{
    public static int ID      = 0;
    public static String NAME = "TEST";
}

Per ottenere un valore, utilizzalo in un'attività:

Info.ID
Info.NAME

Per impostare un valore:

Info.ID = 5;
Info.NAME = "USER!";

È possibile passare i dati tra le attività nell'applicazione in 3 modi 1.Intent 2.SharedPreferences 3.Application

il passaggio dei dati nell'intento ha qualche limite. Per una grande quantità di dati è possibile utilizzare la condivisione dei dati a livello di applicazione e memorizzandola in sharedpref aumenta la dimensione dell'app


Dall'attività

 int n= 10;
 Intent in = new Intent(From_Activity.this,To_Activity.class);
 Bundle b1 = new Bundle();
 b1.putInt("integerNumber",n);
 in.putExtras(b1);
 startActivity(in);

All'attività

 Bundle b2 = getIntent().getExtras();
 int m = 0;
 if(b2 != null)
  {
     m = b2.getInt("integerNumber");
  }

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

Recentemente ho rilasciato Vapor API , un framework Android aromatizzato con jQuery che rende più semplice ogni tipo di attività come questa. Come accennato, SharedPreferencesè un modo per farlo.

VaporSharedPreferencesè implementato come Singleton in modo che sia un'opzione, e in Vapor API ha un .put(...)metodo fortemente sovraccarico , quindi non devi preoccuparti esplicitamente del tipo di dati che stai commettendo, purché sia ​​supportato. È anche fluente, quindi puoi chiamare a catena:

$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);

Inoltre, consente di salvare automaticamente le modifiche e unifica il processo di lettura e scrittura in modo da non dover recuperare in modo esplicito un editor come in Android standard.

In alternativa si potrebbe utilizzare un Intent. In Vapor API è anche possibile utilizzare il .put(...)metodo di sovraccarico concatenabile su a VaporIntent:

$.Intent().put("data", "myData").put("more", 568)...

E passalo come un extra, come menzionato nelle altre risposte. Puoi recuperare extra dal tuo Activity, e inoltre se stai usando VaporActivityquesto è fatto automaticamente per te in modo da poter usare:

this.extras()

Per recuperarli dall'altra parte in cui Activitysi passa a.

Spero che sia interessante per alcuni :)


/*
 * If you are from transferring data from one class that doesn't
 * extend Activity, then you need to do something like this.
 */ 

public class abc {
    Context context;

    public abc(Context context) {
        this.context = context;
    }

    public void something() {
        context.startactivity(new Intent(context, anyone.class).putextra("key", value));
    }
}






android-activity