¿Cómo paso datos entre actividades en la aplicación de Android?

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 button en cada activity.

Al hacer clic sign-out, Estaré pasando el session id del usuario que inició sesión para cerrar la sesión. ¿Alguien puede guiarme sobre cómo mantener session id disponible para todos activities?

Cualquier alternativa a este caso

preguntado el 19 de enero de 10 a las 03:01

Usé la preferencia compartida, también es útil para mantener los datos de inicio de sesión en la función de recordatorio de contraseña:

Esto funciona para mí stackoverflow.com/a/7325248/2125322 Gracias Darshan Computing -

para tales casos, intente crear la clase commomUtils con el método de preferencias compartidas ... esto mantendrá el código limpio y los datos relacionados en un lugar. Y podrá borrar fácilmente un conjunto específico de datos con un solo método para borrar ese archivo de preferencias específico, sin borrar ninguno de los datos predeterminados de la aplicación ... -

30 Respuestas

La forma más sencilla de hacer esto sería pasar el ID de sesión a la actividad de cierre de sesión en el Intent que 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");

La documentos for Intents tiene más información (consulte la sección titulada "Extras").

contestado el 25 de mayo de 19 a las 10:05

ok, si paso el ID de sesión para cerrar la actividad en el inicio de sesión exitoso y ¿funcionará en cualquier página de actividad para cerrar sesión o manualmente tendré que asignarle un valor a cada actividad? usando el procedimiento anterior? - SOLUCIONES UMAR-MOBIT

Sí, tendría que hacer que el ID de sesión esté disponible para todas las actividades en las que desee permitir que el usuario cierre sesión. Alternativamente, puede almacenarlo en el objeto Aplicación, pero luego tendrá que administrar el estado de la sesión (verifique si es válido antes de usarlo, etc.). - erich douglas

Tenga en cuenta que la documentación señala lo siguiente: Agregue datos extendidos a la intención. El nombre debe incluir un prefijo de paquete, por ejemplo, la aplicación com.android.contacts usaría nombres como "com.android.contacts.ShowAll". - serguei fedorov

Y para leer datos de otro uso de actividad Long session_ids=getIntent().getExtras().getLong("EXTRA_SESSION_IDS"); - Farid

¿Cómo podemos pasar datos usando setData y ¿cuál es la diferencia entre estos dos enfoques? ¿Cuál es mejor? - Hosein Aqajani

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
}

Utilice esta técnica para pasar variables de una actividad a otra.

respondido 25 mar '18, 07:03

Solo una información para aquellos que son tan ciegos como yo: si pones un número entero en tu actividad actual, debes obtenerlo en la nueva a través de extras.getInt("new_variable_name"). Si intentas conseguirlo a través de getString() ¡Android ve que se dio un int y devuelve nulo! - bish

¿Qué pasa si la actividad ya se está ejecutando? ¿Es necesario hacer startActivity(i); ? Quiero decir, puedo hacer actividad A llamar al actividad B, y eso devuelve datos a actividad A ? estoy confundido? - Francisco Corrales Morales

Prefiero la variable de cadena. Siempre puede convertir una cadena en entero o flotante más tarde. - user914425

Pasando (Paso) Intención extras es un buen enfoque, como señaló Erich.

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

Puede extender la Aplicación, y luego configurar / obtener lo que desee allí y acceder a ella desde cualquier Actividad (en la misma aplicación) con getApplication ().

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

Respondido el 26 de enero de 10 a las 17:01

+1 para el problema de estática. probablemente la limpieza se pueda resolver combinando un singleton con la clase de aplicación del método onCreate / onTerminate. - sur

Oye, sé que este hilo fue hace bastante tiempo, pero el enlace proporcionado ahora es un callejón sin salida. ¿Hay algún lugar donde pueda encontrar el ejemplo? - Jugo

¿Cómo lograr esto usando la aplicación? @CharlieCollins - Banee Ishaque K

Aquí hay un ejemplo actualizado de esto aquí, de un libro muy antiguo :) github.com/charlieCollins/android-en-practica/blob/master/ch07/… - charlie collins

@JuiCe La publicación del blog de desarrolladores de Android sobre pérdidas de memoria ya no es válida. - Edric

Clase de fuente:

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

respondido 22 nov., 15:12

¿Puede la intención ser nula alguna vez? ¿Debemos comprobar que no sea nulo? - Micro

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

Me gusta:

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

En la OnCreate método de su SecondActivity puedes buscar los extras de esta manera.

Si el valor que enviaste estaba en long:

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

Si el valor que envió fue un String:

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

Si el valor que envió fue un Boolean:

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

Respondido el 14 de Septiembre de 16 a las 04:09

Tenga en cuenta que la documentación señala lo siguiente: Agregue datos extendidos a la intención. El nombre debe incluir un prefijo de paquete, por ejemplo, la aplicación com.android.contacts usaría nombres como "com.android.contacts.ShowAll". - serguei fedorov

Este es un duplicado de la respuesta más votada que ha estado allí durante 2 años antes de esta respuesta y de La respuesta de Sahil Mahajan Mj que es 1 año mayor. Única diferencia: ejemplos de boolean y long captadores que vale la pena un comentario en mi opinión, no una respuesta. - Múrmel

Me ayuda a ver las cosas en contexto. A continuación se muestran dos ejemplos.

Pasar datos hacia adelante

enter image description here

Actividad principal

  • Coloque los datos que desea enviar en un Intent con un par clave-valor. Ver esta respuesta para nombrar convenciones para la clave.
  • Inicie 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

  • Tu usas getIntent() para obtener el Intent que inició la segunda actividad. Entonces puedes extraer los datos con getExtras() y la clave que definiste en la primera actividad. Dado que nuestros datos son una cadena, solo usaremos getStringExtra aquí.

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

Pasando datos de vuelta

enter image description here

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 en realidad sea la Segunda actividad comprobando el código de resultado. (Esto es útil cuando está iniciando varias actividades diferentes desde la misma actividad principal).
  • Extrae los datos que obtuviste de la devolución Intent. Los datos se extraen mediante un par clave-valor. Podría usar cualquier cadena para la clave, pero usaré el predefinido Intent.EXTRA_TEXT ya que estoy enviando un mensaje de 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

  • Coloque los datos que desea enviar a la actividad anterior en un Intent. Los datos se almacenan en el Intent utilizando un par clave-valor. Elegí usar Intent.EXTRA_TEXT por mi llave.
  • Establezca el resultado en RESULT_OK y agregue la intención que contiene sus datos.
  • Llame al 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();
    }
}

Respondido el 17 de enero de 18 a las 17:01

¡Wow gracias! Esto era exactamente lo que estaba buscando. Está bastante claro cuando uso la cámara u otros elementos externos que espero obtener resultados, pero no pensé en usarlo internamente. Eres el primero en decirlo tan abiertamente. - user3195231

Actualizado Tenga en cuenta que he mencionado el uso de Preferencia compartida. 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 para la seguridad si transmite datos confidenciales. Es mejor usar intenciones. Tiene una lista extensa de métodos sobrecargados que se pueden usar para transferir mejor muchos tipos de datos diferentes entre actividades. Mira esto intención.putExtra. Esto aquí presenta bastante bien el uso de putExtra.

Al pasar datos entre actividades, mi enfoque preferido es crear un método estático para la actividad relevante que incluye los parámetros requeridos para lanzar la intención. Que luego proporciona configuraciones y recupera parámetros fácilmente. 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. Puede adaptarse a los fragmentos. Un simple ejemplo anterior, pero ya entiendes la idea.

Respondido el 14 de diciembre de 17 a las 00:12

Me gusta más tu respuesta ... Pasarla a través de la intención significa que en casi todos los lugares donde empiezo una actividad, tendrás que recordar incluir el sessionId. Al colocarlo en SharedPreferences, puede obtenerlo en cualquier momento desde cualquier actividad. : 0) - doblador de bytes

@bytebender Sé que esto es un poco tarde para la respuesta, agradezco que te guste mi respuesta original por su simplicidad, pero tendría cuidado de almacenar la ID de sesión en preferencias compartidas. Si debe almacenarlo en un almacenamiento duro, utilice el cifrado. Si puede usar un marco de autenticación que emplea JWT, incluirá refreshTokens que son más seguros para el almacenamiento a largo plazo y luego mantendrá el token de sesión actual como una propiedad pública de un objeto de aplicación personalizado para acceder fácilmente a los tokens de autenticación y reducir la sobrecarga en la actividad. firmas de intención. - chico enojado

Trate de hacer lo siguiente:

Cree una clase de "ayudante" simple (fábrica para sus Intents), 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 de todos tus Intents. Cada vez que necesite un nuevo Intent, cree un método de fábrica estático en IntentHelper. Para crear un nuevo Intent, 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 este Intent. En la Actividad de destino, 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).

respondido 22 mar '17, 18:03

También puede pasar objetos de clase personalizados haciendo un parcelable clase. 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 compilar y obtendrá un nuevo código. Copie todo esto y reemplace el contenido original de la clase. Luego-

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 puedes simplemente usar el foo objeto como lo hubieras usado.

Respondido el 23 de enero de 17 a las 15:01

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

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Respondido 25 Oct 12, 23:10

Realmente me pregunto por qué su sugerencia no obtuvo votos, es más simple y más práctica. - Porizm

um ... ¿esto no viola los principios de OO? - Cristian Vielma

@ChristianVielma bueno, es más como un área gris ... puedes hacerlo de muchas maneras, para mí parece una "escapada" limpia, así que ... depende de ti (el desarrollador) tomar la decisión si funciona bien para ti o no, me gusta así porque es más fácil de seguir, pero se puede ensuciar muy rápido ... - user497849

¿Por qué dices que esto se ensucia? ¿IOS no hace esto para pasar datos entre controladores de vista estableciendo "propiedades" que es similar a esto? Esto es mucho más fácil que usar intenciones. terry bu

Sí, pasa datos entre controladores de vista, pero no con estático propiedades. El problema es que no es una propiedad en la instancia de actividad deseada. La forma en que Android lanza actividades a través de startActivity (), no crea una instancia instantánea del objeto y permite al desarrollador establecer una variable de instancia. Es bastante molesto ... - Shawn

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 actividad (SecondActivity), debe recuperar los datos de la intención utilizando el siguiente código.

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

respondido 22 nov., 15:10

Este es un duplicado del respuesta más votada que ha estado allí incluso durante 1 año más. - Múrmel

Puedes usar el SharedPreferences...

  1. Inicio sesión. ID de sesión del almacén de tiempo en SharedPreferences

    SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
    Editor editor = preferences.edit();
    editor.putString("sessionId", sessionId);
    editor.commit();
    
  2. Desconectar. ID de sesión de recuperación 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 se guarda el valor y luego se recupera en cualquier lugar de la actividad.

respondido 22 nov., 15:12

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:

Consigue el paquete

Bundle bundle = getIntent().getExtras();

Extrae los datos ...

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

Respondido el 28 de enero de 15 a las 12:01

Duplicar como ya lo propuso PRABEESH RK en 2012. Y podría reducirse a la i.putExtras()/getIntent().getString() que es propuesto por otras 6 respuestas ... - Múrmel

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

Respondido el 24 de enero de 18 a las 15:01

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

Dentro de FirstActivity:

Usando Intent:

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

Dentro de SecondActivity

Bundle bundle= getIntent().getExtras();

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

P.ej bundle.getString("key"),bundle.getDouble("key") ,bundle.getInt("key") etc.

Respondido el 07 de enero de 16 a las 07:01

Duplicar: El Bundle enfoque basado ya fue propuesto por PRABEESH RK en 2012 y Ajay Venugopal. Y podría reducirse a la i.putExtras()/getIntent().getString() que es propuesto por otras 7 respuestas ... - Múrmel

Si desea transferir mapa de bits entre actividades / fragmentos


Actividades

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, Me gusta esto

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

Respondido el 22 de enero de 16 a las 07:01

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

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

respondido 22 nov., 15:12

Esta es mi mejor práctica y ayuda mucho cuando el proyecto es enorme y complejo.

Supongamos que tengo 2 actividades, LoginActivity y HomeActivity. Quiero pasar 2 parámetros (nombre de usuario y contraseña) de LoginActivity a 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 actividad de inicio de sesión

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 estás trabajando en un gran proyecto, es realmente doloroso cuando quieres refactorizar o corregir errores.

Respondido 02 Abr '18, 10:04

Respuesta complementaria: convenciones de nomenclatura para la cadena de claves

El proceso real de pasar datos ya ha sido respondido, sin embargo, la mayoría de las respuestas usan cadenas codificadas para el nombre de la clave en el Intent. Por lo general, esto está bien cuando se usa solo dentro de su aplicación. sin embargo, el la documentación recomienda usando el EXTRA_* constantes para tipos de datos estandarizados.

Ejemplo 1: uso Intent.EXTRA_* claves

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: Definiendo el tuyo propio static final clave

Si uno de los Intent.EXTRA_* Las cadenas no se adaptan a sus necesidades, puede definir las suyas propias 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 una necesidad 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 usar 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));

Respondido el 20 de junio de 20 a las 10:06

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 = intent.getStringExtra("key")

Sugerencia

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

companion object {
    val KEY = "key"
}

Respondido el 18 de enero de 21 a las 03:01

val value = intent.getStringExtra ("clave") - JASKIER

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 del Bundle clase. Luego llame a la actividad usando startActivity() or startActivityForResult() métodos.

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

respondido 22 nov., 15:10

Es más o menos el mismo como usando el Intención proporcionó métodos directamente (Intent#putExtra()). Pero agrega otro Bundle y complica las cosas. - Múrmel

Puede probar Shared Preference, 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);

contestado el 04 de mayo de 17 a las 12:05

Duplicado: este enfoque ya fue propuesto por Ravi Parsania en 2014 - Múrmel

Puedes usar el Intent

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

Otra forma podría ser usar 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;
 }
}

De tu primera actividad

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

En SecondActivity

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

contestado el 31 de mayo de 18 a las 23:05

Duplicado: el enfoque de intención ya ha sido propuesto por respuesta más votada y de La respuesta de Sahil Mahajan Mj y de La respuesta de Mayank Saini y La respuesta de Md. Rahman, La respuesta de Dilavar M, respuesta del desarrollador de Android, sahulab. Singleton: Rodion Altshuler respuesta - Múrmel

Iniciar otra actividad desde esta actividad pasar parámetros a través de Bundle Object

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

Recuperar en otra actividad (YourActivity)

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

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

Aquí tenemos Modelo de empleado

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

    getters...
    setters...
}

Puede usar Gson lib proporcionada por Google para serializar los 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);

Respondido 12 Jul 17, 22:07

Primera forma: en su actividad actual, cuando crea un objeto de intención para abrir una nueva pantalla:

  String value="xyz";
  Intent intent = new Intent(CurrentActivity.this, NextActivity.class);    
  intent.putExtra("key", value);
  startActivity(intent);

Luego, en el método nextActivity in onCreate, recupere los valores que pasa de la actividad anterior:

  if (getIntent().getExtras() != null) {
      String value = getIntent().getStringExtra("key");
      //The key argument must always match that used send and retrive value from one activity to another.
  }

Segunda forma: puede crear un objeto de paquete y poner valores en un paquete y luego poner el objeto de paquete en la intención de su actividad actual -

  String value="xyz";
  Intent intent = new Intent(CurrentActivity.this, NextActivity.class);  
  Bundle bundle = new Bundle();
  bundle.putInt("key", value);  
  intent.putExtra("bundle_key", bundle);
  startActivity(intent);

Luego, en el método nextActivity in onCreate, recupere los valores que pasa de la actividad anterior:

  if (getIntent().getExtras() != null) {
      Bundle bundle = getIntent().getStringExtra("bundle_key");    
      String value = bundle.getString("key");
      //The key argument must always match that used send and retrive value from one activity to another.
  }

También puede utilizar la clase bean para pasar datos entre clases mediante la serialización.

Respondido el 25 de diciembre de 20 a las 12:12

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

Respondido 24 Abr '15, 22:04

Recientemente lancé API de vapor, un marco de Android con sabor a jQuery que simplifica todo tipo de tareas como esta. Como se mencionó, SharedPreferences es una forma de hacer esto.

VaporSharedPreferences se implementa como Singleton, por lo que es una opción, y en Vapor API tiene una sobrecarga .put(...) método para que no tenga que preocuparse explícitamente por 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);

También, opcionalmente, 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, puede usar un Intent. En Vapor API también puedes usar el encadenable sobrecargado .put(...) método en un 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 Activityy, además, si está utilizando VaporActivity esto se hace automáticamente para que pueda usar:

this.extras()

Para recuperarlos en el otro extremo en el Activity al que cambia.

Espero que sea de interés para algunos :)

Respondido 02 Abr '18, 10:04

@BaneeIshaqueK sí lo siento, no he mantenido esto por un tiempo. Tener un enlace actualizado para apuntar directamente al Github para el proyecto en caso de que ayude. PD. No estoy seguro de lo que estaba pensando para esa licencia ... disculpas - Darío

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

Respondido 23 Jul 18, 08:07

Utilice 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 setters y getters 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()

Respondido el 15 de enero de 15 a las 17:01

Aplicación anulada: es un duplicado de La respuesta de quien - Múrmel

Utilizo campos estáticos en una clase y los obtengo / configuro:

Me gusta:

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

Para obtener un valor, use esto en una actividad:

Info.ID
Info.NAME

Para establecer un valor:

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

respondido 22 nov., 15:10

Esta es una mala idea porque Android podría cerrar la actividad y perder efectivamente los datos. - Gerard

@Gerard pero, ¡esta clase no es actividad! - javad

Si todo lo que tiene son constantes, puede crear una interfaz en su lugar. - Aniket Thakur

De nuevo, un enfoque estático, que no es nada nuevo en comparación con Computadora Dice No y Przemek Marcinkiewicz's respuestas. - Múrmel

Evite siempre el uso de estática para campos no constantes. - Asamblea del Islam

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.