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

Tengo un escenario donde, después de iniciar sesión a través de una página de inicio de sesión, habrá un button cerrar sesión en cada activity .

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

Cualquier alternativa a este caso

La forma más fácil de hacerlo sería pasar la identificación de la sesión a la actividad de registro en la 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"); 

Los documentos para Intents tienen más información (consulte la sección titulada “Extras”).

En tu actividad actual, crea 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, recupera 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 los extras de Intent es un buen enfoque, como señaló Erich.

Sin embargo, el objeto Aplicación es 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 las primitivas y las cadenas.

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

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

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 método OnCreate de SecondActivity puedes buscar extras como este.

Si el valor que envió fue 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ó era un Boolean :

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

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. Lo mejor es usar intenciones. Tiene una extensa lista de métodos sobrecargados que se pueden utilizar para transferir mejor muchos tipos de datos diferentes entre actividades. Eche 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 incluye los parámetros requeridos para iniciar la intención. Que luego proporciona parámetros fáciles de configurar y recuperar. 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 un bash para la actividad prevista y asegurarse de tener todos los parámetros. Puedes adaptar los fragmentos a. Un simple ejemplo anterior, 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 todos sus Intents. Cada vez que necesite un nuevo Intento, cree un método de fábrica estático en IntentHelper. Para crear una nueva intención, solo debe decirlo así:

 IntentHelper.createYourSpecialIntent(getIntent()); 

En tu actividad Cuando desee “guardar” algunos datos en una “sesión”, solo use lo siguiente:

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

Y envía este Intento. En la Actividad objective, 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 ).

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

Pasar datos adelante

enter image description here

Actividad principal

  • Coloque los datos que desea enviar en una intención con un par clave-valor. Vea esta respuesta para nombrar convenciones 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

  • Utiliza getIntent() para obtener la Intent que inició la segunda actividad. Luego puede extraer los datos con getExtras() y la clave que definió 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 termina la Segunda Actividad. Puede asegurarse de que en realidad sea la Segunda Actividad al verificar el código de resultado. (Esto es útil cuando se inician múltiples actividades diferentes desde la misma actividad principal).
  • Extraiga los datos que obtuvo de la Intent devolución. Los datos se extraen utilizando un par clave-valor. Podría usar cualquier cadena para la clave, pero Intent.EXTRA_TEXT el Intent.EXTRA_TEXT predefinido ya 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

  • Coloque los datos que desea devolver a la actividad anterior en un Intent . Los datos se almacenan en el Intent utilizando un par clave-valor. Elegí usar Intent.EXTRA_TEXT para mi clave.
  • Establezca el resultado en RESULT_OK y agregue el bash que contiene sus datos.
  • finish() llamada 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(); } } 

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

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

y obtenga el resultado en NextActivity like-

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

Ahora puedes simplemente usar el objeto foo como lo hubieras usado.

Otra forma es utilizar un campo público estático en el que almacena 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 la que desea enviar datos, debe agregar el 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 el siguiente Acitvity (SecondActivity), debe recuperar los datos de la intención utilizando el siguiente código.

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

Puede usar SharedPreferences

  1. Explotación florestal. Time store store id en SharedPreferences

     SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE); Editor editor = preferences.edit(); editor.putString("sessionId", sessionId); editor.commit(); 
  2. Desconectar. Tiempo de búsqueda de id de sesión en sharedpreferences

     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 parte de la 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:

Obtener el paquete

 Bundle bundle = getIntent().getExtras(); 

Extrae 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 usando el objeto intencional. Considere que tiene dos actividades, a saber, FirstActivity y SecondActivity .

Dentro de FirstActivity:

Uso de la intención:

 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.

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

Si desea transferir bitmap entre Activites / Fragments


Actividad

Pasar un bitmap entre Activites

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

Y en la clase de Actividad

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

Fragmento

Pasar un bitmap entre Fragmentos

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

Para recibir dentro de SecondFragment

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

Transferencia de mapas de bits grandes

Si obtiene una transacción de encuadernación fallida, esto significa que está excediendo el búfer de transacción del encuadernador transfiriendo un elemento grande de una actividad a otra.

Entonces, en ese caso, debe comprimir el bitmap 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"); 

Respuesta suplementaria: Convenciones de nombres para el String clave

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 Intento. Esto generalmente está bien cuando se usa solo dentro de su aplicación. Sin embargo, la documentación recomienda usar las constantes EXTRA_* para tipos de datos estandarizados.

Ejemplo 1: uso de las teclas Intent.EXTRA_*

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: definición de su propia clave static final

Si uno de los Intent.EXTRA_* Strings no se ajusta a sus necesidades, puede definir el suyo 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 está usando la clave en su propia aplicación. Pero es una necesidad evitar el nombramiento de conflictos si está creando algún tipo de servicio que otras aplicaciones puedan llamar con un Intento.

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 String

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

strings.xml

  com.myPackageName.MY_NAME 

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

Puede probar la 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); 

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

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

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

Aquí es cómo 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, aquí es cómo 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 trabajas en un proyecto pequeño, este no debería ser el gran problema. Pero cuando trabajas en un proyecto grande, realmente duele cuando quieres refactorizar o corregir errores.

El paso de datos entre actividades es principalmente por medio de un objeto intencional.

Primero debe adjuntar los datos al objeto intencionado con el uso de la clase Bundle . Luego llame a la actividad utilizando los startActivity() o startActivityForResult() .

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

Charlie Collins me dio una respuesta perfecta usando Application.class . No sabía que podríamos subclasificar eso tan fácilmente. Aquí hay un ejemplo simplificado que usa una clase de aplicación personalizada.

AndroidManifest.xml

Dale el atributo android:name para usar tu propia clase de aplicación.

 ...  .... 

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

Puedes usar Intent

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

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

 public class DataHolder { private static DataHolder dataHolder; private List dataList; public void setDataList(ListdataList) { this.dataList = dataList; } public List getDataList() { return dataList; } public synchronized static DataHolder getInstance() { if (dataHolder == null) { dataHolder = new DataHolder(); } return dataHolder; } } 

De su FirstActivity

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

En SecondActivity

 private List dataList = DataHolder.getInstance().getDataList(); 
 /* * 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)); } } 

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

Prueba esto:

CurrentActivity.java

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

TargetActivity.java

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

Comience otra actividad desde esta actividad pase 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 el 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... } 

Puedes usar Gson lib provisto 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() { }.getType(); Employee selectedEmp = gson.fromJson(empStr, type); 

I recently released Vapor API , a jQuery flavored Android framework that makes all sorts of tasks like this simpler. As mentioned, SharedPreferences is one way you could do this.

VaporSharedPreferences is implemented as Singleton so that is one option, and in Vapor API it has a heavily overloaded .put(...) method so you don’t have to explicitly worry about the datatype you are committing – providing it is supported. It is also fluent, so you can chain calls:

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

It also optionally autosaves changes, and unifies the reading and writing process under-the-hood so you don’t need to explicitly retrieve an Editor like you do in standard Android.

Alternatively you could use an Intent . In Vapor API you can also use the chainable overloaded .put(...) method on a VaporIntent :

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

And pass it as an extra, as mentioned in the other answers. You can retrieve extras from your Activity , and furthermore if you are using VaporActivity this is done for you automatically so you can use:

 this.extras() 

To retrieve them at the other end in the Activity you switch to.

Hope that is of interest to some 🙂

If you use kotlin:

In MainActivity1:

 var intent=Intent(this,MainActivity2::class.java) intent.putExtra("EXTRA_SESSION_ID",sessionId) startActivity(intent) 

In MainActivity2:

 if (intent.hasExtra("EXTRA_SESSION_ID")){ var name:String=intent.extras.getString("sessionId") } 

You can pass data between activities in application in 3 ways 1.Intent 2.SharedPreferences 3.Application

passing data in intent have some limit.For large amount of data you can use Application level data sharing and by storing it in sharedpref makes your app size increase