¿Cómo puedo pasar 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 inicio de sesión en cada activity .

Al hacer clic en el inicio de sesión, pasaré el session id de session id del usuario firmado para cerrar sesión. ¿Puede alguien guiarme sobre cómo mantener el session id disponible para todas las activities ?

Cualquier alternativa a este caso

    La forma más sencilla de hacerlo sería pasar el identificador de sesión a la actividad de cierre de sesión en la intención que está utilizando para iniciar la actividad:

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

    Acceda a la siguiente actividad

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

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

    En su Actividad actual, cree un nuevo Propósito:

     Intent i = new Intent(getApplicationContext(), 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 } 

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

    Passing Intent extras es un buen enfoque como Erich señaló.

    Sin embargo, el objeto Application es otra forma, ya veces es más fácil cuando se trata del mismo estado en varias actividades (en lugar de tener que ponerlo en todas partes) o en objetos más complejos que primitivos y cadenas.

    Puede extender la aplicación y, a continuación, establecer / obtener lo que desea allí y acceder a ella desde cualquier actividad (en la misma aplicación) con getApplication () .

    También tenga en cuenta que otros enfoques que pueda ver, como la estática, pueden ser problemáticos, ya que pueden conducir a 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"); } 

    Sólo 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 su SecondActivity puede obtener los extras como este.

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

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

    Actualizado Tenga en cuenta que he mencionado 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 se pasa alrededor de datos sensibles. Es mejor usar las intenciones. Tiene una lista extensa de métodos sobrecargados que se pueden utilizar 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.

    Intente hacer lo siguiente:

    Cree una clase simple de "ayudante" (fábrica para sus intentos), como esto:

     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 tus intentos. Cada vez que necesite una nueva intención, cree un método estático de fábrica en IntentHelper. Para crear una nueva Intención debes decirlo así:

     IntentHelper.createYourSpecialIntent(getIntent()); 

    En su actividad. Cuando quiera "guardar" algunos datos en una "sesión" simplemente use lo siguiente:

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

    Y envíe esta Intención. En la Actividad de destino su campo estará disponible como:

     getIntent().getStringExtra("YOUR_FIELD_NAME"); 

    Así que ahora podemos usar Intent como la misma sesión antigua (como en servlets o JSP ).

    También puede pasar objetos de clase personalizados haciendo una clase parcelable . La mejor manera de hacerla parcelable es escribir su clase y entonces simplemente pegarla a 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 puedes simplemente usar el objeto foo como lo habrías usado.

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

     public class MyActivity extends Activity { public static String SharedString; public static SomeObject SharedObject; //... 

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

    Extraer los datos …

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

    La manera más conveniente de pasar datos entre las actividades es pasar intenciones. En la primera actividad desde la que 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 debe importar

     import android.content.Intent; 

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

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

    Puede utilizar SharedPreferences

    1. Explotación florestal. ID de sesión de 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 búsqueda de tiempo en las preferencias compartidas

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

    Si no tiene el identificador de sesión necesario, 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.

    De la actividad

      int n= 10; Intent in = new Intent(From_Activity.this,To_Activity.class); Bundle b1 = new Bundle(); b1.putInt("integerNumber",n); in.putExtras(b1); startActivity(in); 

    A la actividad

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

    Puede enviar datos entre actividades utilizando el objeto de intención. Considere que tiene dos actividades, a saber, 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 utilizar diferentes métodos de clase de paquete para obtener valores pasados ​​de FirstActivity by Key.

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

    Si desea transferir bitmap entre Activites / Fragments


    Actividad

    Para pasar un mapa de bits 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

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

    Transferir mapas de bits grandes

    Si está recibiendo una transacción de enlace fallido, significa que está excediendo el binder buffer de transacción al transferir elementos grandes de una actividad a otra.

    Así que en ese caso usted tiene que comprimir el mapa de bits como una matriz de bytes y luego descomprimirlo en otra actividad , como este

    En la FirstActivity

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

    Y en SecondActivity

     byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes"); Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length); 
     Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class); intent.putExtra("NAme","John"); intent.putExtra("Id",1); startActivity(intent); 

    Puede recuperarla en otra actividad. Dos caminos:

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

    La segunda forma es:

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

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

    Para guardar el id de 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); 

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

    Primero tiene que adjuntar los datos al objeto de intención con el uso de la clase Bundle . A continuación, llame a la actividad utilizando los startActivity() o startActivityForResult() .

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

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

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

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

    En primer lugar, 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 SplashActivity

     public class SplashActivity extends AppCompatActivity { @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_splash); 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 SplashActivity //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! Cool 🙂 Sólo quiero compartir mi experiencia. Si usted trabaja en un proyecto pequeño esto no debería ser el gran problema. Pero cuando estás trabajando en un gran proyecto, es realmente dolor cuando quieres hacer refactorización o arreglar errores.

     /* * 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 / los fijo:

    Me gusta:

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

    Para obtener un valor, utilícelo en una actividad:

     Info.ID Info.NAME 

    Para establecer un valor:

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

    Respuesta suplementaria: Convenciones de nomenclatura para la cadena de claves

    El proceso real de transmisión de datos ya ha sido contestado, sin embargo la mayoría de las respuestas utilizan cadenas codificadas duras para el nombre de clave en el intento. Normalmente, esto se aplica cuando se utiliza sólo en la aplicación. Sin embargo, la documentación recomienda utilizar las constantes EXTRA_* para tipos de datos estandarizados.

    Ejemplo 1: Utilizar 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 una de las Intent.EXTRA_* no se adapta a sus necesidades, puede definir la suya al principio de la primera actividad.

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

    Incluir el nombre del paquete es sólo una convención si sólo utiliza la clave en su propia aplicación. Pero es necesario evitar los conflictos de nombres si está creando algún tipo de servicio que otras aplicaciones pueden 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 de cadena

    Aunque no se menciona en la documentación, esta respuesta recomienda utilizar un recurso de cadena para evitar dependencias entre las 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)); 

    Puede utilizar Intent

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

    Otra forma en que puede utilizar 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 su FirstActivity

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

    En SecondActivity

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

    Recientemente he lanzado Vapor API , una jQuery Android marco que hace todo tipo de tareas como esta más simple. Como se mencionó, SharedPreferences es una forma de hacerlo.

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

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

    También opcionalmente los cambios de autosave, y unifica el proceso de lectura y escritura bajo el capó por lo que no es necesario recuperar explícitamente un Editor como lo hace en el estándar de Android.

    Alternativamente, usted podría usar una Intent . En Vapor API también puede usar el .put(...) sobrecarga .put(...) en un VaporIntent :

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

    Y pasarlo como un extra, como se menciona en las otras respuestas. Puede recuperar los extras de su Activity y, además, si está usando VaporActivity esto se hace automáticamente para que pueda utilizar:

     this.extras() 

    Para recuperarlos en el otro extremo de la Activity que cambia.

    Espero que sea de interés para algunos 🙂

    Utilizar 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 ya los getters de esta clase de todas las otras clases. Haga eso, necesita hacer un objeto GlobalClass en cada Actitity:

     GlobalClass gc = (GlobalClass) getApplication(); 

    Entonces puede llamar por ejemplo:

     gc.getVitaminA() 

    Charlie Collins me dio una respuesta perfecta usando la clase de aplicación. No sabía que podríamos subclases tan fácilmente. A continuación se muestra un ejemplo simplificado que utiliza una clase de aplicación personalizada.

    AndroidManifest.xml

    Dé el atributo android:name 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 sencillo en el que utilizo 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(); } } } 

    Utilizo campos públicos estáticos para almacenar datos compartidos entre actividades, pero para minimizar sus efectos secundarios, puede:

    • Hacer sólo un campo, o tan pocos como sea posible, y reutilizarlos, hacerlos de tipo objeto y arrojarlo al tipo deseado en la actividad de recepción.
    • Siempre que alguno de ellos no sea útil, póngalo explícitamente a null para ser recogido por el recolector de basura, antes de la siguiente asignación.

    Hay varias maneras de pasar datos entre actividades, y la documentación tiene muchas de ellas.

    Para la mayoría de los casos, Intent.putExtras es suficiente.

    // Su problema es que desea almacenar ID de sesión después de iniciar sesión y disponible ese id de sesión para cada actividad en la que desea cerrar la sesión.

    // La solución de su problema es que tiene que almacenar su ID de sesión después de un inicio de sesión correcto en una variable pública. Y siempre que necesite id de sesión para salir, puede acceder a esa variable y reemplazar el valor de las variables a cero.

     //Serializable class public class YourClass implements Serializable { public long session_id = 0; } 
    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.