Ho uno scenario in cui, dopo aver effettuato l'accesso attraverso una pagina di accesso, ci sarà una disconnessione buttonsu ciascunoactivity .

Facendo clic sign-out, session idpasserò all'utente che ha effettuato l'accesso per uscire. Qualcuno può guidarmi su come tenermi session iddisponibile a tutti activities?

Qualsiasi alternativa a questo caso

Il modo più semplice per farlo sarebbe passare l'id di sessione all'attività signout nell'utente Intentche stai utilizzando per avviare l'attività:

Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);

Accedi a quell'intento sulla prossima attività:

String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");

La documentazione per Intenti contiene ulteriori informazioni (consulta la sezione "Extra").

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à, recuperare 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
}

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

Intenzione di passaggio extra di è un buon approccio, come ha osservato Erich.

L' applicazione oggetto è un altro modo, tuttavia, ed è talvolta più facile quando si tratta dello stesso stato in più attività (al contrario di doverlo ottenere / metterlo ovunque), o oggetti più complessi di primitivi e stringhe.

È possibile estendere l'applicazione, quindi impostare / ottenere ciò che si desidera lì e accedervi 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 causare perdite di memoria . L'applicazione aiuta a risolvere anche questo.

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 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 OnCreatetuo metodo SecondActivitypuoi recuperare gli extra in questo modo.

Se il valore inviato era inlong :

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

Se il valore inviato era aString :

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

Se il valore inviato era aBoolean :

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

Mi aiuta a vedere le cose nel contesto. Ecco due esempi.

Inoltro dati in avanti

Attività principale

• Inserisci i dati che desideri inviare in un Intento con una coppia chiave-valore. Vedi questa risposta per le convenzioni di denominazione per la chiave.
• Inizia la seconda attività con startActivity.

MainActivity.java

public class MainActivity extends AppCompatActivity {

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // get the text to pass
        EditText editText = (EditText) findViewById(R.id.editText);
        String textToPass = editText.getText().toString();

        // start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        intent.putExtra(Intent.EXTRA_TEXT, textToPass);
        startActivity(intent);
    }
}

Seconda attività

• Usi getIntent()per ottenere quello Intentche ha iniziato la seconda attività. Quindi è possibile estrarre i dati con getExtras()e la chiave definita nella prima attività. Poiché i nostri dati sono una stringa, utilizzeremo solo getStringExtraqui.

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

        // get the text from MainActivity
        Intent intent = getIntent();
        String text = intent.getStringExtra(Intent.EXTRA_TEXT);

        // use the text in a TextView
        TextView textView = (TextView) findViewById(R.id.textView);
        textView.setText(text);
    }
}

Restituzione dei dati

Attività principale

• Inizia la seconda attività con startActivityForResult, fornendo un codice risultato arbitrario.
• Oltrepassare onActivityResult . Questo viene chiamato al termine della Seconda attività. Puoi assicurarti che sia effettivamente la seconda attività controllando il codice del risultato. (Ciò è utile quando si avviano più attività diverse dalla stessa attività principale.)
• Estrai i dati che hai ricevuto dal reso Intent. I dati vengono estratti utilizzando una coppia chiave-valore. Potrei usare qualsiasi stringa per la chiave ma userò il predefinito Intent.EXTRA_TEXTpoiché sto inviando del testo.

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private static final int SECOND_ACTIVITY_REQUEST_CODE = 0;

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // Start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);
    }

    // This method is called when the second activity finishes
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // check that it is the SecondActivity with an OK result
        if (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {

                // get String data from Intent
                String returnString = data.getStringExtra(Intent.EXTRA_TEXT);

                // set text view with string
                TextView textView = (TextView) findViewById(R.id.textView);
                textView.setText(returnString);
            }
        }
    }
}

Seconda attività

• Inserire i dati che si desidera rinviare all'attività precedente in un Intent. I dati vengono archiviati in Intentusando una coppia chiave-valore. Ho scelto di utilizzare Intent.EXTRA_TEXTper la mia chiave.
• Imposta il risultato su RESULT_OKe aggiungi l'intento che contiene i tuoi dati.
• Chiama finish()per chiudere la seconda attività.

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

    // "Send text back" button click
    public void onButtonClick(View view) {

        // get the text from the EditText
        EditText editText = (EditText) findViewById(R.id.editText);
        String stringToPassBack = editText.getText().toString();

        // put the String to pass back into an Intent and close this activity
        Intent intent = new Intent();
        intent.putExtra(Intent.EXTRA_TEXT, stringToPassBack);
        setResult(RESULT_OK, intent);
        finish();
    }
}

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 gli intenti. Ha un ampio elenco di metodi sovraccarichi che possono essere utilizzati per trasferire meglio diversi tipi di dati tra attività. Dai un'occhiata a intent.putExtra . Questo link presenta abbastanza bene l'uso di putExtra.

Nel passare i dati tra le attività, il mio approccio preferito è quello di creare un metodo statico per l'attività pertinente che includa i parametri richiesti per avviare l'intento. Che quindi fornisce facilmente l'impostazione e il recupero dei parametri. Quindi può sembrare così

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 ai frammenti di. Un semplice esempio sopra, ma hai avuto l'idea.

Prova a fare quanto segue:

Crea una semplice classe "helper" (factory for your Intents), in questo modo:

import android.content.Intent;

public class IntentHelper {
    public static final Intent createYourSpecialIntent(Intent src) {
          return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
    }
}

Questa sarà la fabbrica per tutti i tuoi intenti. Ogni volta che hai bisogno di un nuovo intento, crea un metodo factory statico in IntentHelper. Per creare un nuovo Intento dovresti semplicemente dirlo in questo modo:

IntentHelper.createYourSpecialIntent(getIntent());

Nella tua attività. Quando si desidera "salvare" alcuni dati in una "sessione", utilizzare quanto segue:

IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);

E invia questo Intento. Nell'attività target il tuo campo sarà disponibile come:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Quindi ora possiamo usare Intent come la stessa vecchia sessione (come in servlet o JSP ).

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

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

e ottieni il risultato in NextActivity come-

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

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

Un altro modo è utilizzare un campo statico pubblico in cui archiviare i dati, ovvero:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Il modo più conveniente per passare i dati tra le attività è passare gli intenti. Nella prima attività da cui si desidera inviare i dati, è necessario aggiungere 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), dovresti recuperare i dati dall'intento usando il seguente codice.

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

Puoi usare SharedPreferences...

1. Registrazione. ID sessione time store inSharedPreferences

   SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
   Editor editor = preferences.edit();
   editor.putString("sessionId", sessionId);
   editor.commit();

2. Disconnessione. ID sessione time fetch in preferenze condivise

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

Se non disponi dell'ID sessione richiesto, rimuovi le preferenze condivise:

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

Questo è molto utile, perché una volta salvi il valore e poi recuperi ovunque l'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 bundle:

Ottieni il pacchetto

Bundle bundle = getIntent().getExtras();

Estrai i dati ...

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

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

È possibile inviare dati tra attività usando intent object. Considera di avere due attività FirstActivitye cioè SecondActivity.

Inside FirstActivity:

Utilizzo dell'intento:

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

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

Ora puoi utilizzare diversi metodi di classe bundle per ottenere valori passati da FirstActivity per chiave.

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

Se si desidera trasferire bitmap tra attività / frammenti

Attività

Per passare una bitmap tra Activites

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

E nella classe Activity

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

Frammento

Per passare una bitmap tra i frammenti

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

Per ricevere all'interno del SecondFragment

Bitmap bitmap = getArguments().getParcelable("bitmap");

Trasferimento di bitmap di grandi dimensioni

Se si verificano transazioni del raccoglitore non riuscite, ciò significa che si sta superando il buffer delle transazioni del raccoglitore trasferendo un elemento di grandi dimensioni da un'attività a un'altra.

Quindi in quel caso devi comprimere la bitmap come un array di byte e quindi decomprimerla in un'altra attività , come questa

In FirstActivity

Intent intent = new Intent(this, SecondActivity.class);

ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray(); 
intent.putExtra("bitmapbytes",bytes);

E in SecondActivity

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

Puoi recuperarlo in un'altra attività. Due strade:

int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);

Il secondo modo è:

Intent i = getIntent();
String name = i.getStringExtra("name");

Ecco la mia migliore pratica e aiuta molto quando il progetto è enorme e complesso.

Supponiamo che io abbia 2 attività LoginActivitye HomeActivity. Voglio passare 2 parametri (nome utente e password) da LoginActivitya HomeActivity.

Innanzitutto, creo il mio HomeIntent

public class HomeIntent extends Intent {

    private static final String ACTION_LOGIN = "action_login";
    private static final String ACTION_LOGOUT = "action_logout";

    private static final String ARG_USERNAME = "arg_username";
    private static final String ARG_PASSWORD = "arg_password";


    public HomeIntent(Context ctx, boolean isLogIn) {
        this(ctx);
        //set action type
        setAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);
    }

    public HomeIntent(Context ctx) {
        super(ctx, HomeActivity.class);
    }

    //This will be needed for receiving data
    public HomeIntent(Intent intent) {
        super(intent);
    }

    public void setData(String userName, String password) {
        putExtra(ARG_USERNAME, userName);
        putExtra(ARG_PASSWORD, password);
    }

    public String getUsername() {
        return getStringExtra(ARG_USERNAME);
    }

    public String getPassword() {
        return getStringExtra(ARG_PASSWORD);
    }

    //To separate the params is for which action, we should create action
    public boolean isActionLogIn() {
        return getAction().equals(ACTION_LOGIN);
    }

    public boolean isActionLogOut() {
        return getAction().equals(ACTION_LOGOUT);
    }
}

Ecco come passo i dati nel mio LoginActivity

public class LoginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        String username = "phearum";
        String password = "pwd1133";
        final boolean isActionLogin = true;
        //Passing data to HomeActivity
        final HomeIntent homeIntent = new HomeIntent(this, isActionLogin);
        homeIntent.setData(username, password);
        startActivity(homeIntent);

    }
}

Passaggio finale, ecco come ricevo i dati HomeActivity

public class HomeActivity extends AppCompatActivity {

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

        //This is how we receive the data from LoginActivity
        //Make sure you pass getIntent() to the HomeIntent constructor
        final HomeIntent homeIntent = new HomeIntent(getIntent());
        Log.d("HomeActivity", "Is action login?  " + homeIntent.isActionLogIn());
        Log.d("HomeActivity", "username: " + homeIntent.getUsername());
        Log.d("HomeActivity", "password: " + homeIntent.getPassword());
    }
}

Fatto! Fantastico :) Voglio solo condividere la mia esperienza. Se lavori su piccoli progetti, questo non dovrebbe essere il grosso problema. Ma quando lavori su un grande progetto, è davvero doloroso quando vuoi fare refactoring o correggere bug.

Risposta supplementare: Convenzioni di denominazione per la stringa chiave

Il processo effettivo di trasmissione dei dati ha già ricevuto risposta, tuttavia la maggior parte delle risposte utilizza stringhe codificate per il nome della chiave nell'Intento. Questo di solito va bene se utilizzato solo all'interno della tua app. Tuttavia, la documentazione consiglia di utilizzare le EXTRA_*costanti per tipi di dati standardizzati.

Esempio 1: utilizzo dei Intent.EXTRA_*tasti

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 static finalchiave

Se una delle Intent.EXTRA_*stringhe non soddisfa le tue esigenze, puoi definire 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 si utilizza solo la chiave nella propria app. Ma è necessario evitare conflitti di denominazione se si sta creando una sorta 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 di utilizzare una risorsa String per evitare 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));

Puoi usare Intent

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

Un altro modo potrebbe essere utilizzare anche il modello singleton :

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 prima attività

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

On SecondActivity

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

Il passaggio di dati tra le attività avviene principalmente mediante un oggetto intento.

Per prima cosa devi collegare i dati all'oggetto intento con l'uso della Bundleclasse. Quindi chiamare l'attività utilizzando uno dei metodi startActivity()o startActivityForResult().

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

Puoi provare la preferenza condivisa, potrebbe essere una buona alternativa per la condivisione dei dati tra le attività

Per salvare l'ID sessione:

SharedPreferences pref = myContexy.getSharedPreferences("Session 
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();

Per ottenerli -

SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);

Inizia un'altra attività da questa attività passa parametri tramite Bundle Object

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

Recupera su un'altra attività (YourActivity)

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

Questo va bene per un tipo di dati di tipo semplice. Ma se vuoi trasferire dati complessi tra un'attività, devi prima serializzarli.

Qui abbiamo il modello dei dipendenti

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

    getters...
    setters...
}

Puoi utilizzare la libreria Gson fornita 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);

Kotlin

Passa dalla prima attività

val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)

Entra nella seconda attività

val value = getIntent().getStringExtra("key")

Suggerimento

Metti sempre le chiavi in ​​un file costante per un modo più gestito.

companion object {
    val KEY = "key"
}

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

Charlie Collins mi ha dato una risposta perfetta usando il Application.class. Non ero a conoscenza del fatto che potevamo sottoclassarlo così facilmente. Ecco un esempio semplificato che utilizza una classe di applicazione personalizzata.

AndroidManifest.xml

Assegna l' android:nameattributo per usare la tua classe di applicazione.

...
<application android:name="MyApplication"
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
....

MyApplication.java

Usalo come detentore di riferimento globale. Funziona bene all'interno di uno stesso processo.

public class MyApplication extends Application {
    private MainActivity mainActivity;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }
    public MainActivity getMainActivity() { return mainActivity; }
}

MainActivity.java

Imposta il riferimento globale "singleton" all'istanza dell'applicazione.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ((MyApplication)getApplication()).setMainActivity(this);
    }
    ...

}

MyPreferences.java

Un semplice esempio in cui utilizzo un'attività principale di un'altra istanza di attività.

public class MyPreferences extends PreferenceActivity
            implements SharedPreferences.OnSharedPreferenceChangeListener {
    @SuppressWarnings("deprecation")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
        if (!key.equals("autostart")) {
            ((MyApplication)getApplication()).getMainActivity().refreshUI();
        }
    }
}

Di recente ho rilasciato Vapor API , un framework Android basato su jQuery che semplifica ogni tipo di attività come questa. Come accennato, SharedPreferencesè un modo per farlo.

VaporSharedPreferencesè implementato come Singleton, quindi questa è un'opzione e nell'API di Vapor ha un .put(...)metodo fortemente sovraccarico , quindi non devi preoccuparti esplicitamente del tipo di dati che stai commettendo - a condizione che sia supportato. È anche fluente, quindi puoi concatenare le chiamate:

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

Facoltativamente, salva automaticamente le modifiche e unifica il processo di lettura e scrittura sottotitoli, quindi non è necessario recuperare esplicitamente un editor come in Android standard.

In alternativa puoi usare un Intent. In Vapor API puoi anche usare il .put(...)metodo di sovraccarico concatenabile su un VaporIntent:

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

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

this.extras()

Per recuperarli dall'altra parte, Activitysi passa a.

Spero che sia di interesse per alcuni :)

Prima attività:

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

Seconda attività:

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

È possibile passare i dati tra le attività nell'applicazione in 3 modi

1. Intento
2. SharedPreferences
3. Applicazione

il passaggio di dati nell'intento ha qualche limite. Per grandi quantità di dati puoi utilizzare la condivisione dei dati a livello di applicazione e memorizzandola in SharedPreference aumenta le dimensioni della tua app

Usa una classe globale:

public class GlobalClass extends Application
{
    private float vitamin_a;


    public float getVitaminA() {
        return vitamin_a;
    }

    public void setVitaminA(float vitamin_a) {
        this.vitamin_a = vitamin_a;
    }
}

Puoi chiamare i setter e i getter di questa classe da tutte le altre classi. Per fare ciò, è necessario creare un oggetto GlobalClass in tutte le attività:

GlobalClass gc = (GlobalClass) getApplication();

Quindi puoi chiamare per esempio:

gc.getVitaminA()