una - ¿Cómo paso datos entre Actividades en la aplicación de Android?

putextra android para que sirve

Question

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 cierre de sesión en cada activity .

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

Cualquier alternativa a este caso

Answer 1

Respuesta suplementaria: Convenciones de nomenclatura para la cadena de 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 clave en la Intención. Esto usualmente está bien cuando se usa solo dentro de su aplicación. Sin embargo, la documentación recomienda usar las constantes EXTRA_* para los 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: Definiendo tu propia clave static final

Si una de las Intent.EXTRA_* 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 está usando la clave en su propia aplicación. Pero es una necesidad para evitar conflictos de nombres si está creando algún tipo de servicio al que otras aplicaciones pueden 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 de 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));

Answer 2

Charlie Collins me dio una answer perfecta usando Application.class . No sabía que pudiéramos subclasificar tan fácilmente. Aquí hay un ejemplo simplificado usando 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

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

Answer 3

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

Answer 4

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 tu segunda actividad recupera tus datos del paquete:

Obtener el paquete

Bundle bundle = getIntent().getExtras();

Extraer los datos ...

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

Answer 5

El paso de datos entre actividades es principalmente por medio de un objeto de intención.

Primero, debe adjuntar los datos al objeto de intento con el uso de la clase Bundle . Luego, llame a la actividad usando 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 .

Answer 6

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
}

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

Answer 7

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 estás trabajando en un proyecto pequeño, este no debería ser el gran problema. Pero cuando estás trabajando en un gran proyecto, realmente te duele cuando quieres refactorizar o corregir errores.

Answer 8

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", "[email protected]");
startActivity(intent);

Recuperar en otra actividad (YourActivity)

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

Esto está bien para el tipo de datos de tipo simple. Pero si desea pasar datos complejos entre la actividad, 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 proporcionado 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);

Answer 9

La forma más conveniente de pasar datos entre 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 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");

Answer 10

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

Accede a esa intención en la siguiente actividad.

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

La docs para intenciones tiene más información (consulte la sección titulada "Extras").

Answer 11

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

Pasando los datos hacia adelante

Actividad principal

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

• 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. Como 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

Actividad principal

• Comience la segunda actividad con startActivityForResult , proporcionándole un código de resultado arbitrario.
• Anular onActivityResult . Esto se llama cuando la segunda actividad termina. Puede asegurarse de que en realidad es la Segunda Actividad verificando 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 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 enviar a la actividad anterior en una Intent . Los datos se almacenan en la Intent utilizando un par clave-valor. Elegí usar Intent.EXTRA_TEXT para mi clave.
• Establezca el resultado en RESULT_OK y agregue la intención que contiene sus datos.
• Llame a 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();
    }
}

Answer 12

Otra forma es usar 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;

//...

Answer 13

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

Sin embargo, el objeto Application es otra forma, y ​​a veces es más fácil cuando se trata del mismo estado en múltiples actividades (en lugar de tener que ponerlo en cualquier lugar), u objetos más complejos que los primitivos y las Cadenas.

Puede extender la Aplicación, y luego configurar / obtener lo que quiera 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 los estáticos, pueden ser problemáticos porque pueden provocar pérdidas de memoria . La aplicación ayuda a resolver esto también.

Answer 14

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

Answer 15

Puede enviar datos entre actividades utilizando objeto de intención. FirstActivity cuenta que tienes dos actividades: FirstActivity y SecondActivity .

Dentro de FirstActivity:

Usando la intención:

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

Dentro de la segunda actividad

Bundle bundle= getIntent().getExtras();

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

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

Answer 16

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

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

Answer 17

Puedes usar Intent

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

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

De tu primera actividad

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

En la segunda actividad

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

Answer 18

Puedes usar las SharedPreferences ...

1. Explotación florestal. 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 las 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.

Answer 19

Solo tienes que enviar extras al llamar tu 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 tu SecondActivity puedes 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 enviaste fue una String :

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

Si el valor que enviaste fue un Boolean :

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

Answer 20

También puede pasar objetos de clase personalizados haciendo una clase parcelable . La mejor manera de hacer que sea parcelable es escribir su clase y luego pegarlo en un sitio como http://www.parcelabler.com/ . Haga clic en construir y obtendrá nuevo código. Copia todo esto y reemplaza 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 obtener el resultado en NextActivity como-

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

Ahora puedes simplemente usar el objeto foo como habrías usado.

Answer 21

Tenga en cuenta que había 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 pasa información confidencial. 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. Echa un vistazo a intent.putExtra . Este link 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 necesarios para lanzar la intención. Que a continuación, proporciona una fácil configuración y recuperación de parámetros. Así 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 que tiene todos los parámetros. Se puede adaptar para fragmentos a. Un ejemplo simple arriba, pero entiendes la idea.

Answer 22

Trate de hacer lo siguiente:

Cree una clase simple de "ayudante" (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 intentos. Cada vez que necesite un nuevo Intent, 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", use lo siguiente:

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

Y envía este intento. En la Actividad objetivo su campo estará disponible como:

getIntent().getStringExtra("YOUR_FIELD_NAME");

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

Answer 23

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

Answer 24

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 del SecondFragment

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

Transferencia de grandes mapas de bits

Si está obteniendo una transacción de archivador fallida, esto significa que está excediendo el búfer de transacción de vinculación transfiriendo el elemento grande de una actividad a otra actividad.

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

En la primeraactividad

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

Answer 25

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

Answer 26

Puede pasar datos entre actividades en la aplicación de 3 maneras 1.Intent 2.SharedPreferences 3.Application

los datos que se pasan con intención tienen algún límite. Para una gran cantidad de datos, puede usar el uso compartido de datos a nivel de la aplicación y al almacenarlo en la preferencia compartida aumenta el tamaño de la aplicación

Answer 27

Si usas kotlin:

En MainActivity1:

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

En MainActivity2:

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

Answer 28

Recientemente lancé Vapor API , un framework para Android con sabor a 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 la API de Vapor tiene un .put(...)método muy sobrecargado 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);

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

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

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

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

this.extras()

Para recuperarlos en el otro extremo Activity, cambie a.

Espero que sea de interés para algunos :)

Answer 29

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

Answer 30

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