Tengo un escenario en el que, después de iniciar sesión a través de una página de inicio de sesión, habrá un cierre de sesión buttonen cada uno activity.

Al hacer clic sign-out, pasaré el session idusuario registrado para cerrar sesión. ¿Alguien puede guiarme sobre cómo mantenerme session iddisponible para todos activities?

Cualquier alternativa a este caso

La forma más fácil de hacer esto sería pasar la identificación de la sesión a la actividad de cierre de sesión en la Intentque está utilizando para iniciar la actividad:

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

Acceda a esa intención en la próxima actividad:

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

Los documentos para Intents tienen más información (mira la sección titulada "Extras").

En su Actividad actual, cree una nueva Intent:

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

Luego, en la nueva Actividad, recupere esos valores:

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

Use esta técnica para pasar variables de una Actividad a la otra.

Pasar intenciones extras es un buen enfoque, como señaló Erich.

Sin embargo, el objeto Aplicación es otra forma, y ​​a veces es más fácil cuando se trata con el mismo estado en múltiples actividades (en lugar de tener que obtenerlo / ponerlo en todas partes) u objetos más complejos que las primitivas y las cadenas.

Puede extender la aplicación y luego configurar / obtener lo que desee allí y acceder a él desde cualquier actividad (en la misma aplicación) con getApplication () .

También tenga en cuenta que otros enfoques que puede ver, como las estadísticas, pueden ser problemáticos porque pueden provocar pérdidas de memoria . La aplicación también ayuda a resolver esto.

Clase de origen:

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

Clase de destino (clase 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");
}

Solo tiene que enviar extras mientras llama a su intención.

Me gusta esto:

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

Ahora en el OnCreatemétodo de tu SecondActivitypuedes buscar los extras como este.

Si el valor que envió estaba enlong :

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

Si el valor que envió fue unString :

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

Si el valor que envió fue unBoolean :

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

Me ayuda a ver las cosas en contexto. Aquí hay dos ejemplos.

Transmitir datos hacia adelante

Actividad principal

• Ponga los datos que desea enviar en una intención con un par clave-valor. Consulte esta respuesta para conocer las convenciones de nomenclatura para la clave.
• Comience la segunda actividad 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);
    }
}

Segunda actividad

• Se usa getIntent()para Intentiniciar la segunda actividad. Luego puede extraer los datos getExtras()y la clave que definió en la primera actividad. Como nuestros datos son una cadena, solo la usaremos getStringExtraaquí.

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

Pasar datos de vuelta

Actividad principal

• Inicie la segunda actividad con startActivityForResult, proporcionándole un código de resultado arbitrario.
• Anular onActivityResult. Esto se llama cuando finaliza la segunda actividad. Puede asegurarse de que realmente sea la segunda actividad al verificar el código de resultado. (Esto es útil cuando está iniciando múltiples actividades diferentes desde la misma actividad principal).
• Extraiga los datos que obtuvo de la declaración Intent. Los datos se extraen utilizando un par clave-valor. Podría usar cualquier cadena para la clave, pero usaré la predefinida Intent.EXTRA_TEXTya que estoy enviando texto.

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

Segunda actividad

• Ponga los datos que desea enviar de vuelta a la actividad anterior en un Intent. Los datos se almacenan Intentutilizando un par clave-valor. Elegí usar Intent.EXTRA_TEXTpara mi clave.
• Establezca el resultado RESULT_OKy agregue la intención que contiene sus datos.
• Llame finish()para cerrar la segunda actividad.

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 actualizada que mencioné el uso de SharedPreference . Tiene una API simple y es accesible a través de las actividades de una aplicación. Pero esta es una solución torpe y es un riesgo de seguridad si pasa datos confidenciales. Es mejor usar intenciones. Tiene una extensa lista de métodos sobrecargados que se pueden usar para transferir mejor muchos tipos de datos diferentes entre actividades. Echa un vistazo a intent.putExtra . Este enlace presenta el uso de putExtra bastante bien.

Al pasar datos entre actividades, mi enfoque preferido es crear un método estático para la actividad relevante que incluya los parámetros requeridos para lanzar la intención. Que luego proporciona fácilmente la configuración y recuperación de parámetros. Entonces puede verse así

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

Luego puede crear una intención para la actividad prevista y asegurarse de tener todos los parámetros. Se puede adaptar para fragmentos a. Un ejemplo simple de arriba, pero entiendes la idea.

Intenta hacer lo siguiente:

Cree una clase simple de "ayuda" (fábrica para sus intenciones), como esta:

import android.content.Intent;

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

Esta será la fábrica para todas sus intenciones. Cada vez que necesite una nueva intención, cree un método de fábrica estático en IntentHelper. Para crear una nueva intención, solo debes decirlo así:

IntentHelper.createYourSpecialIntent(getIntent());

En tu actividad. Cuando desee "guardar" algunos datos en una "sesión", utilice lo siguiente:

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

Y envía esta intención. En la Actividad objetivo, su campo estará disponible como:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Entonces, ahora podemos usar Intent como la misma sesión anterior (como en servlets o JSP ).

También puede pasar objetos de clase personalizados haciendo una clase parcelable . La mejor manera de hacerlo parcelable es escribir su clase y luego simplemente pegarla en un sitio como http://www.parcelabler.com/ . Haga clic en construir y obtendrá un nuevo código. Copie todo esto y reemplace el contenido original de la clase. Entonces-

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

y obtener el resultado en NextActivity como-

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

Ahora puede simplemente usar el objeto foo como lo hubiera hecho.

Otra forma es usar un campo público estático en el que almacene datos, es decir:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

La forma más conveniente de pasar datos entre actividades es pasando intenciones. En la primera actividad desde donde desea enviar datos, debe agregar código,

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

También deberías importar

import android.content.Intent;

Luego, en la siguiente Acitvity (SecondActivity), debe recuperar los datos de la intención utilizando el siguiente código.

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

Puedes usar SharedPreferences...

1. Inicio sesión. Id. De sesión de almacén de tiempo enSharedPreferences

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

2. Desconectar. ID de sesión de búsqueda de tiempo en preferencias compartidas

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

Si no tiene el ID de sesión requerido, elimine las preferencias compartidas:

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

Eso es muy útil, porque una vez guarda el valor y luego recupera cualquier lugar de actividad.

El enfoque estándar.

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

Ahora, en su segunda actividad, recupere sus datos del paquete:

Obtén el paquete

Bundle bundle = getIntent().getExtras();

Extraer los datos ...

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

De la actividad

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

A la actividad

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

Puede enviar datos entre actividades utilizando el objeto de intención. Considere que tiene dos actividades, a saber, FirstActivityy SecondActivity.

Inside FirstActividad:

Intención de uso:

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

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

Ahora puede usar diferentes métodos de clase de paquete para obtener los valores pasados ​​de FirstActivity por Key.

Por ejemplo bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")etc.

Si desea transferir un mapa de bits entre Actividades / Fragmentos

Actividad

Para pasar un mapa de bits entre actividades

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

Y en la clase de actividad

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

Fragmento

Para pasar un mapa de bits entre fragmentos

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

Para recibir dentro del SecondFragment

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

Transferencia de mapas de bits grandes

Si obtiene una transacción de carpeta fallida, esto significa que está excediendo el búfer de transacción de carpeta al transferir un elemento grande de una actividad a otra.

Entonces, en ese caso, debe comprimir el mapa de bits como una matriz de bytes y luego descomprimirlo en otra actividad , como esta

En la primera actividad

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

Y en la segunda actividad

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

Puedes recuperarlo en otra actividad. Dos caminos:

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

La segunda forma es:

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

Aquí está mi mejor práctica y ayuda mucho cuando el proyecto es enorme y complejo.

Supongamos que tengo 2 actividades, LoginActivityy HomeActivity. Quiero pasar 2 parámetros (nombre de usuario y contraseña) de LoginActivitya HomeActivity.

Primero, creo mi 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);
    }
}

Así es como paso los datos en mi 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);

    }
}

Paso final, así es como recibo los datos en 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());
    }
}

¡Hecho! Genial :) Solo quiero compartir mi experiencia. Si trabaja en un proyecto pequeño, este no debería ser el gran problema. Pero cuando trabajas en un gran proyecto, es realmente doloroso cuando quieres refactorizar o corregir errores.

Respuesta suplementaria: convenciones de nomenclatura para la cadena clave

El proceso real de pasar datos ya ha sido respondido, sin embargo, la mayoría de las respuestas utilizan cadenas codificadas para el nombre de la clave en la intención. Esto generalmente está bien cuando se usa solo dentro de su aplicación. Sin embargo, la documentación recomienda utilizar las EXTRA_*constantes para los tipos de datos estandarizados.

Ejemplo 1: uso de Intent.EXTRA_*teclas

Primera actividad

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

Segunda actividad:

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

Ejemplo 2: definir tu propia static finalclave

Si una de las Intent.EXTRA_*cadenas no se ajusta a sus necesidades, puede definir la suya al comienzo de la primera actividad.

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

Incluir el nombre del paquete es solo una convención si solo usa la clave en su propia aplicación. Pero es necesario evitar conflictos de nombres si está creando algún tipo de servicio al que otras aplicaciones puedan llamar con una intención.

Primera actividad:

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

Segunda actividad:

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

Ejemplo 3: uso de una clave de recurso de cadena

Aunque no se menciona en la documentación, esta respuesta recomienda utilizar un recurso String para evitar dependencias entre actividades.

strings.xml

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

Primera actividad

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

Segunda actividad

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

Puedes usar Intent

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

Otra forma podría ser usar el patrón singleton también:

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

Desde tu primera actividad

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

En SecondActivity

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

El paso de datos entre actividades se realiza principalmente mediante un objeto de intención.

Primero debe adjuntar los datos al objeto de intención con el uso de la Bundleclase. A continuación, llame la actividad usando ya sea startActivity()o startActivityForResult()métodos.

Puede encontrar más información al respecto, con un ejemplo de la publicación del blog Pasando datos a una Actividad .

Puede probar Preferencia compartida, puede ser una buena alternativa para compartir datos entre las actividades.

Para guardar la identificación de la sesión:

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

Para conseguirlos -

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

Inicie otra actividad desde esta actividad pasando parámetros a través de Bundle Object

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

Recuperar en otra actividad (YourActivity)

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

Esto está bien para un tipo de datos simple y amable. Pero si desea pasar datos complejos entre actividades, primero debe serializarlos.

Aquí tenemos el modelo de empleado

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

    getters...
    setters...
}

Puede usar Gson lib proporcionado por google para serializar datos complejos como este

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

Pase de la primera actividad

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

Entra en la segunda actividad

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

Sugerencia

Siempre coloque las claves en un archivo constante para una forma más administrada.

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 me dio una respuesta perfecta usando el Application.class. No sabía que podíamos subclasificarlo tan fácilmente. Aquí hay un ejemplo simplificado usando una clase de aplicación personalizada.

AndroidManifest.xml

Otorgue el android:nameatributo para usar su propia clase de aplicación.

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

MyApplication.java

Use esto como un titular de referencia global. Funciona bien dentro de un mismo proceso.

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

Establezca la referencia global "singleton" a la instancia de la aplicación.

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 ejemplo simple donde uso una actividad principal de otra instancia de actividad.

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

Recientemente lancé Vapor API , un marco de Android con jQuery que simplifica todo tipo de tareas como esta. Como se mencionó, SharedPreferenceses una forma de hacer esto.

VaporSharedPreferencesse implementa como Singleton, por lo que es una opción, y en Vapor API tiene un .put(...)método muy sobrecargado para que no tenga que preocuparse explícitamente sobre el tipo de datos que está confirmando, siempre que sea compatible. También es fluido, por lo que puede encadenar llamadas:

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

Opcionalmente, también guarda automáticamente los cambios y unifica el proceso de lectura y escritura bajo el capó para que no necesite recuperar explícitamente un Editor como lo hace en Android estándar.

Alternativamente, podría usar un Intent. En Vapor API también puede usar el .put(...)método encadenado sobrecargado en VaporIntent:

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

Y páselo como un extra, como se menciona en las otras respuestas. Puede recuperar extras de su Activity, y además, si está usando, VaporActivityesto se hace automáticamente para que pueda usar:

this.extras()

Para recuperarlos en el otro extremo en el Activity que cambie.

Espero que sea de interés para algunos :)

Primera actividad:

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

Segunda actividad:

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

Puede pasar datos entre actividades en la aplicación de 3 maneras

1. Intención
2. Preferencias compartidas
3. Solicitud

pasar datos en la intención tiene algún límite. Para una gran cantidad de datos, puede usar el uso compartido de datos a nivel de aplicación y al almacenarlos en SharedPreference aumenta el tamaño de su aplicación

Use una clase global:

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

Puede llamar a los establecedores y captadores de esta clase desde todas las demás clases. Haga eso, necesita hacer un GlobalClass-Object en cada Actitity:

GlobalClass gc = (GlobalClass) getApplication();

Entonces puedes llamar por ejemplo:

gc.getVitaminA()