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

1349

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

UMAR
fuente
14
utilicé sharedpreference, es útil también para mantener los datos de inicio de sesión en la función
recordar
Esto funciona para mi. stackoverflow.com/a/7325248/2125322 Gracias Darshan Computing
matasoy
stackoverflow.com/a/37774966/6456129 puede ser útil
Yessy
para tales casos intente hacer la clase commomUtils con el método de preferencias compartidas ... esto mantendrá el código limpio y los datos relacionados en un lugar. Y usted será capaz de Claro conjunto específico de datos con sólo un método de limpieza que prefrencesFile específica, sin borrar ninguno de datos de aplicaciones por defecto ...
Muahmmad Tayyib

Respuestas:

1266

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

Erich Douglass
fuente
ok si paso la identificación de la sesión para cerrar sesión en la actividad de inicio de sesión exitoso y ¿funcionará en cualquier página de actividad para cerrar sesión o manualmente tendré que asignarle un valor en cada actividad? utilizando el procedimiento anterior?
UMAR
55
Sí, tendría que hacer que el ID de sesión esté disponible para cada actividad en la que desee permitir que el usuario cierre sesión. Alternativamente, podría almacenarlo en el objeto Aplicación, pero luego tendría que administrar el estado de la sesión (verifique si es válido antes de usarlo, etc.).
Erich Douglass
1
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
1
Y para leer los datos de otras actividades de usoLong session_ids=getIntent().getExtras().getLong("EXTRA_SESSION_IDS");
Farid
1
¿Cómo podemos pasar datos usando setDatay cuál es la diferencia entre estos dos enfoques? ¿Cuál es mejor?
Hosein Aqajani
1402

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.

usuario914425
fuente
58
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 el nuevo a través de extras.getInt("new_variable_name"). Si intenta obtenerlo a través de getString()Android, vea que se le dio un int y devuelve nulo.
Bish
44
¿Qué pasa si la actividad ya se está ejecutando, hay que hacer startActivity(i);? Quiero decir, ¿puedo hacer que la actividad A llame a la actividad B , y eso devuelve datos a la actividad A ? estoy confundido?
Francisco Corrales Morales
Prefiero cadena variable. Siempre puede convertir una cadena a entero o flotante más tarde.
user914425
140

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.

Charlie Collins
fuente
8
+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.
Syd
10
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?
JuiCe
¿Cómo lograr esto usando la aplicación? @CharlieCollins
Ishaque K
Aquí hay un ejemplo actualizado de esto aquí, de un libro muy antiguo :) github.com/charlieCollins/android-in-practice/blob/master/ch07/…
Charlie Collins
@JuiCe La publicación del blog de desarrolladores de Android sobre pérdidas de memoria ya no es inválida.
Edric
94

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");
}
MD Rahman
fuente
3
¿Puede la intención ser alguna vez nula? ¿Deberíamos comprobar que no es nulo?
Micro
Este es un duplicado de la respuesta más votada de 3 años más antigua y de la respuesta de Sahil Mahajan Mj y de la respuesta de
Mayank
85

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);
Mayank Saini
fuente
3
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 el
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. La única diferencia: ejemplos booleany longcaptadores que vale la pena comentar en mi opinión, no una respuesta.
Murmel
48

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

Transmitir datos hacia adelante

ingrese la descripción de la imagen aquí

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

ingrese la descripción de la imagen aquí

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();
    }
}
Suragch
fuente
3
¡Wow gracias! Esto era bastante lo que estaba buscando. Es 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
45

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.

angryITguy
fuente
2
Me gusta más tu respuesta ... Pasarla por la intención significa que en casi todos los lugares donde empiezo una actividad tendrás que recordar incluir el Id. De sesión. Al colocarlo en SharedPreferences, puede obtenerlo en cualquier momento desde cualquier actividad. : 0)
bytebender
@bytebender Sé que es un poco tarde para la respuesta, agradezco que le guste mi respuesta original por su simplicidad, pero sería cuidadoso al almacenar la ID de la sesión en las preferencias compartidas. Si debe almacenarlo en un disco duro, use cifrado. Si puede usar un marco de autenticación que emplee 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.
angryITguy
38

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

Ponkin
fuente
28

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.

Vaibhav Sharma
fuente
23

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 computadora dice que no
fuente
55
Realmente me pregunto por qué su sugerencia no obtuvo votos, es más simple y más práctica.
Porizm
77
um ... ¿esto no viola los principios de OO?
Christian Vielma
2
@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 usted o no, me gusta de esta manera porque es más fácil de seguir, pero puede ensuciarse muy rápido ...
ComputerSaysNo
2
¿Por qué dices que esto se ensucia? ¿IOS no hace esto para pasar datos entre viewcontrollers configurando "propiedades" que es similar a esto? Esto es mucho más fácil que usar intentos
Terry Bu
2
Sí, pasa datos entre controladores de vista, pero no con propiedades estáticas . El problema es que no es una propiedad en la instancia de actividad deseada. La forma en que Android inicia actividades a través de startActivity (), no crea instancias instantáneamente del objeto y permite al desarrollador establecer una variable de instancia. Es bastante molesto ...
Shawn
20

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");
Sahil Mahajan Mj
fuente
2
Este es un duplicado de la respuesta más votada que ha estado allí por incluso 1 año más.
Murmel
19

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.

Ravi Parsania
fuente
17

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”); 
Ajay Venugopal
fuente
1
Duplicado como ya lo propuso PRABEESH RK en 2012. Y podría reducirse a i.putExtras()/ getIntent().getString()propuesto por otras 6 respuestas ...
Murmel
17

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");
  }
Gavine Joyce
fuente
1
Duplicado: el Bundleenfoque basado ya fue propuesto por PRABEESH RK en 2012 y Ajay Venugopal , Krishna . Y podría reducirse al i.putExtras()/ getIntent().getString()que es propuesto por otras 8 respuestas ...
Murmel
11

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.

Krishna
fuente
1
Duplicado: el Bundleenfoque basado ya fue propuesto por PRABEESH RK en 2012 y Ajay Venugopal . Y podría reducirse al i.putExtras()/ getIntent().getString()que es propuesto por otras 7 respuestas ...
Murmel
11

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);
capt.swag
fuente
9
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");
Dilavar Malek
fuente
8

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.

THANN Phearum
fuente
7

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

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();
Sachin
fuente
Duplicar: El enfoque de la intención ya está propuesto por la parte superior respuesta más votada y de la respuesta de Sahil Mahajan Mj y de la respuesta de Mayank Saini y respuesta de Rahman Md. , La respuesta de Dilavar M , la respuesta de desarrollador de Android , sahulab . Singleton: respuesta de Rodion Altshuler
Murmel
6

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 .

PRABEESH RK
fuente
Esto es más o menos lo mismo que usar los métodos proporcionados por Intent directamente ( Intent#putExtra()). Pero agrega otro Bundley hace las cosas más complicadas.
Murmel
6

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);
Rohit Gurjar
fuente
Duplicado: este enfoque ya fue apoyado por Ravi Parsania en 2014
Murmel el
5

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);
DroidNinja
fuente
5

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"
}
Khemraj
fuente
4
/*
 * 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));
    }
}
Dip Pokhrel
fuente
4

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

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

Darius
fuente
@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
Darius
4

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");
suresh madaparthi
fuente
4

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

Lavanya Velusamy
fuente
3

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()
Patricia Heimfarth
fuente
Solicitud primordial: este es un duplicado de la respuesta de
Whome