Android
Intención

Introducción

Sintaxis

• Intención Intención ()
• Intención Intención (Intención intención)
• Intención Intención (acción de cuerdas)
• Intención Intención (String action, Uri uri)
• Intención Intención (Context packageContext, Class <?> Cls)
• Intención Intención (Acción de cadena, Uri uri, Context packageContext, Class <?> Cls)
• void startActivity (Intención de intención)
• void startActivity (Intención de intento, opciones de paquete)
• void startActivityForResult (Intención de intención, int requestCode)
• void startActivityForResult (Intención de intento, int requestCode, opciones de paquete)
• Intención putExtra (nombre de cadena, doble [] valor)
• Intención putExtra (nombre de cadena, valor int)
• Intención putExtra (nombre de cadena, valor CharSequence)
• Intención putExtra (nombre de cadena, valor char)
• Intención putExtra (nombre de cadena, valor de paquete)
• Intención putExtra (nombre de cadena, valor parcelable [])
• Intención putExtra (nombre de cadena, valor serializable)
• Intención putExtra (nombre de cadena, valor int [])
• Intención putExtra (nombre de cadena, valor flotante)
• Intención putExtra (nombre de cadena, byte [] valor)
• Intención putExtra (nombre de cadena, valor largo [])
• Intención putExtra (nombre de cadena, valor parcelable)
• Intención putExtra (nombre de la cadena, valor [] flotante)
• Intención putExtra (nombre de cadena, valor largo)
• Intención putExtra (nombre de cadena, cadena [] valor)
• Intención putExtra (nombre de cadena, valor booleano)
• Intención putExtra (nombre de cadena, valor booleano [])
• Intención putExtra (nombre de cadena, valor corto)
• Intención putExtra (nombre de cadena, doble valor)
• Intención putExtra (nombre de cadena, valor corto [])
• Intención putExtra (nombre de cadena, valor de cadena)
• Intención putExtra (nombre de cadena, valor de byte)
• Intención putExtra (nombre de cadena, valor char [])
• Intención putExtra (nombre de cadena, valor CharSequence [])

Parámetros

Observaciones

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

Iniciar una actividad

Este ejemplo iniciará DestinationActivity desde OriginActivity .

Aquí, el constructor Intent toma dos parámetros:

1. Un contexto como su primer parámetro (esto se usa porque la clase de actividad es una subclase de contexto)
2. La clase del componente de la aplicación a la que el sistema debe entregar la intención (en este caso, la actividad que debe iniciarse)

public class OriginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);

        Intent intent = new Intent(this, DestinationActivity.class);
        
        startActivity(intent);
        finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity again.
    }
}

Otra forma de crear el Intent para abrir DestinationActivity es usar el constructor predeterminado para el Intent , y usar el método setClass() para decirle qué Actividad abrir:

Intent i=new Intent();
i.setClass(this, DestinationActivity.class);
startActivity(intent);
finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity 

Pasando datos entre actividades.

Este ejemplo ilustra el envío de una String con valor como "Some data!" de OriginActivity a DestinationActivity .

NOTA: Esta es la forma más sencilla de enviar datos entre dos actividades. Vea el ejemplo sobre el uso del patrón de inicio para una implementación más robusta.

OrigenActividad

public class OriginActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);
        
        // Create a new Intent object, containing DestinationActivity as target Activity.
        final Intent intent = new Intent(this, DestinationActivity.class);

        // Add data in the form of key/value pairs to the intent object by using putExtra()
        intent.putExtra(DestinationActivity.EXTRA_DATA, "Some data!");

        // Start the target Activity with the intent object
        startActivity(intent);
    }
} 

DestinoActividad

public class DestinationActivity extends AppCompatActivity {

    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_destination);

        // getIntent() returns the Intent object which was used to start this Activity
        final Intent intent = getIntent();

        // Retrieve the data from the intent object by using the same key that
        // was previously used to add data to the intent object in OriginActivity.
        final String data = intent.getStringExtra(EXTRA_DATA);
    }
}

También es posible pasar otros primitive tipos de datos, así como arrays , Bundle y Parcelable datos. También es posible pasar a Serializable , pero debe evitarse ya que es más de tres veces más lento que Parcelable .

Serializable es una interface estándar de Java. Simplemente marque una clase como Serializable implementando la interface Serializable y Java lo serializará automáticamente durante las situaciones requeridas.

Parcelable es una interface específica de Android que puede implementarse en tipos de datos personalizados (es decir, sus propios objetos / objetos POJO), permite que su objeto se aplane y se reconstruya sin que el destino tenga que hacer nada. Hay un ejemplo de documentación de hacer un objeto parcelable .

Una vez que tenga un objeto parcelable , puede enviarlo como un tipo primitivo, con un objeto de intención:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

O en un paquete / como un argumento para un fragmento:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

y luego también leerlo desde la intención en el destino usando getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

O al leer en un fragmento de un paquete:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Una vez que tenga un objeto Serializable , puede ponerlo en un objeto de intención:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

y luego léalo del objeto de intención en el destino como se muestra a continuación:

final SerializableType data = (SerializableType)bundle.getSerializable(EXTRA_DATA); 

Mandando correos electrónicos

// Compile a Uri with the 'mailto' schema
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
        "mailto","[email protected]", null));
// Subject
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Hello World!");
// Body of email
emailIntent.putExtra(Intent.EXTRA_TEXT, "Hi! I am sending you a test email.");
// File attachment
emailIntent.putExtra(Intent.EXTRA_STREAM, attachedFileUri);

// Check if the device has an email client
if (emailIntent.resolveActivity(getPackageManager()) != null) {
     // Prompt the user to select a mail app
     startActivity(Intent.createChooser(emailIntent,"Choose your mail application"));
} else {
    // Inform the user that no email clients are installed or provide an alternative
}

Esto completará previamente un correo electrónico en una aplicación de correo de la elección del usuario.

Si necesita agregar un archivo adjunto, puede usar Intent.ACTION_SEND lugar de Intent.ACTION_SENDTO . Para varios archivos adjuntos puedes usar ACTION_SEND_MULTIPLE

Una palabra de advertencia: no todos los dispositivos tienen un proveedor para ACTION_SENDTO , y llamar a startActivity() sin verificar con resolveActivity() primero puede lanzar una ActivityNotFoundException.

Obtener un resultado de otra actividad

Al usar startActivityForResult(Intent intent, int requestCode) puede iniciar otra Activity y luego recibir un resultado de esa Activity en el onActivityResult(int requestCode, int resultCode, Intent data) . El resultado será devuelto como Intent . Un intento puede contener datos a través de un paquete

En este ejemplo, MainActivity iniciará una DetailActivity y luego esperará un resultado. Cada tipo de solicitud debe tener su propia int código de petición, de modo que en el reemplazado onActivityResult(int requestCode, int resultCode, Intent data) método en el MainActivity , se puede determinar que la solicitud para procesar mediante la comparación de valores de requestCode y REQUEST_CODE_EXAMPLE (aunque en este ejemplo, solo hay uno).

Actividad principal:

public class MainActivity extends Activity {

    // Use a unique request code for each use case 
    private static final int REQUEST_CODE_EXAMPLE = 0x9345; 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create a new instance of Intent to start DetailActivity
        final Intent intent = new Intent(this, DetailActivity.class);

        // Start DetailActivity with the request code
        startActivityForResult(intent, REQUEST_CODE_EXAMPLE);
    }

    // onActivityResult only get called 
    // when the other Activity previously started using startActivityForResult
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // First we need to check if the requestCode matches the one we used.
        if(requestCode == REQUEST_CODE_EXAMPLE) {

            // The resultCode is set by the DetailActivity
            // By convention RESULT_OK means that whatever
            // DetailActivity did was executed successfully
            if(resultCode == Activity.RESULT_OK) {
                // Get the result from the returned Intent
                final String result = data.getStringExtra(DetailActivity.EXTRA_DATA);

                // Use the data - in this case, display it in a Toast.
                Toast.makeText(this, "Result: " + result, Toast.LENGTH_LONG).show();
            } else {
                // setResult wasn't successfully executed by DetailActivity 
                // Due to some error or flow of control. No data to retrieve.
            }
        }
    }
}

DetailActividad:

public class DetailActivity extends Activity {

    // Constant used to identify data sent between Activities.
    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        final Button button = (Button) findViewById(R.id.button);
        // When this button is clicked we want to return a result
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // Create a new Intent object as container for the result
                final Intent data = new Intent();

                // Add the required data to be returned to the MainActivity
                data.putExtra(EXTRA_DATA, "Some interesting data!");
                
                // Set the resultCode as Activity.RESULT_OK to 
                // indicate a success and attach the Intent
                // which contains our result data
                setResult(Activity.RESULT_OK, data); 

                // With finish() we close the DetailActivity to 
                // return back to MainActivity
                finish();
            }
        });
    }

    @Override
    public void onBackPressed() {
        // When the user hits the back button set the resultCode 
        // as Activity.RESULT_CANCELED to indicate a failure
        setResult(Activity.RESULT_CANCELED);
        super.onBackPressed();
    }
}

Algunas cosas que debes tener en cuenta:

• Los datos solo se devuelven una vez que llama a finish() . setResult() llamar a setResult() antes de llamar a finish() , de lo contrario, no se devolverá ningún resultado.

• Asegúrese de que su Activity no esté usando android:launchMode="singleTask" , o la Activity ejecutará en una tarea separada y, por lo tanto, no recibirá ningún resultado de ella. Si su Activity utiliza singleTask como modo de inicio, activará onActivityResult() inmediatamente con un código de resultado de Activity.RESULT_CANCELED .

• Tenga cuidado al usar android:launchMode="singleInstance" . En los dispositivos anteriores a Lollipop (Android 5.0, nivel API 21), Actividades no devolverá un resultado.

• Puede usar intentos explícitos o implícitos cuando llama a startActivityForResult() . Al iniciar una de sus propias actividades para recibir un resultado, debe utilizar un intento explícito para asegurarse de que recibe el resultado esperado. Una intent explícita siempre se entrega a su objetivo, sin importar lo que contenga; El filter no es consultado. Pero un intento implícito se entrega a un componente solo si puede pasar a través de uno de los filtros del componente.

Abre una URL en un navegador

Apertura con el navegador predeterminado

Este ejemplo muestra cómo puede abrir una URL programáticamente en el navegador web incorporado en lugar de dentro de su aplicación. Esto permite que su aplicación abra una página web sin la necesidad de incluir el permiso de INTERNET en su archivo de manifiesto.

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    // Verify that the intent will resolve to an activity
    if (intent.resolveActivity(getPackageManager()) != null) {
        // Here we use an intent without a Chooser unlike the next example
        startActivity(intent);
    } 
}

Pedir al usuario que seleccione un navegador

Tenga en cuenta que este ejemplo utiliza el método Intent.createChooser() :

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    // Note the Chooser below. If no applications match, 
    // Android displays a system message.So here there is no need for try-catch.
    startActivity(Intent.createChooser(intent, "Browse with"));
   
}

En algunos casos, la URL puede comenzar con "www" . Si ese es el caso, obtendrás esta excepción:

android.content.ActivityNotFoundException : no se encontró ninguna actividad para manejar la intención

La URL siempre debe comenzar con "http: //" o "https: //" . Por lo tanto, su código debe verificarlo, como se muestra en el siguiente fragmento de código:

if (!url.startsWith("https://") && !url.startsWith("http://")){
    url = "http://" + url;
}
Intent openUrlIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
if (openUrlIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(openUrlIntent);
} 

Mejores prácticas

Compruebe si no hay aplicaciones en el dispositivo que puedan recibir la intención implícita. De lo contrario, su aplicación se bloqueará cuando llame a startActivity() . Para verificar primero que exista una aplicación para recibir la intención, llame a resolveActivity() en su objeto Intención. Si el resultado no es nulo, hay al menos una aplicación que puede manejar la intención y es seguro llamar a startActivity() . Si el resultado es nulo, no debe usar la intención y, si es posible, debe deshabilitar la función que invoca la intención.

Borrar una pila de actividades

A veces, es posible que desee iniciar una nueva actividad mientras elimina actividades anteriores de la pila trasera, para que el botón Atrás no lo lleve de vuelta a ellas. Un ejemplo de esto podría ser iniciar una aplicación en la actividad de inicio de sesión, que lo lleve a la actividad principal de su aplicación, pero al cerrar la sesión desea volver a iniciar sesión sin tener la posibilidad de volver. En un caso así, puede establecer el indicador FLAG_ACTIVITY_CLEAR_TOP para la intención, lo que significa que si la actividad que se está iniciando ya se está ejecutando en la tarea actual (LoginActivity), en lugar de lanzar una nueva instancia de esa actividad, todas las otras actividades en la parte superior se cerrará y esta Intención se entregará a la actividad antigua (ahora arriba) como una Intención nueva.

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

También es posible usar los indicadores FLAG_ACTIVITY_NEW_TASK junto con FLAG_ACTIVITY_CLEAR_TASK si desea borrar todas las Actividades en la pila de atrás:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
// Closing all the Activities, clear the back stack.
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

Intención URI

Este ejemplo muestra, cómo iniciar la intención desde el navegador:

<a href="intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end">Start intent</a>

Este intento iniciará la aplicación con el paquete com.sample.test o abrirá Google Play con este paquete.

También esta intención se puede iniciar con javascript:

var intent = "intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end";
window.location.replace(intent)

En la actividad, este host y la ruta se pueden obtener a partir de los datos de intención:

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    Uri data = getIntent().getData(); // returns host.com/path
}

Sintaxis de URI de intención:

HOST/URI-path // Optional host
#Intent;
    package=[string];
    action=[string];
    category=[string];
    component=[string];
    scheme=[string];
end;

Transmisión de mensajes a otros componentes

Los intentos se pueden usar para transmitir mensajes a otros componentes de su aplicación (como un servicio en segundo plano en ejecución) o al sistema Android completo.

Para enviar una transmisión dentro de su aplicación , use la clase LocalBroadcastManager :

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
manager.sendBroadcast(intent);

Para enviar una difusión a componentes fuera de su aplicación, use el método sendBroadcast() en un objeto de Context .

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

context.sendBroadcast(intent);

La información sobre las transmisiones de recepción se puede encontrar aquí: Receptor de difusión

CustomTabsIntent para Chrome Custom Tabs

String url = "https://www.google.pl/";
CustomTabsIntent intent = new CustomTabsIntent.Builder()
                    .setStartAnimations(getContext(), R.anim.slide_in_right, R.anim.slide_out_left)
                    .setExitAnimations(getContext(), android.R.anim.slide_in_left, android.R.anim.slide_out_right)
                    .setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back_white_24dp))
                    .setToolbarColor(Color.parseColor("#43A047"))
                    .enableUrlBarHiding()
                    .build();
            intent.launchUrl(getActivity(), Uri.parse(url));

compile 'com.android.support:customtabs:24.1.1'

Compartiendo múltiples archivos a través de la intención

La Lista de cadenas que se pasa como parámetro al método share() contiene las rutas de todos los archivos que desea compartir.

Básicamente recorre las rutas, las agrega a Uri e inicia la Actividad que puede aceptar archivos de este tipo.

  public static void share(AppCompatActivity context,List<String> paths) {

        if (paths == null || paths.size() == 0) {
            return;
        }
        ArrayList<Uri> uris = new ArrayList<>();
        Intent intent = new Intent();
        intent.setAction(android.content.Intent.ACTION_SEND_MULTIPLE);
        intent.setType("*/*");
        for (String path : paths) {
                File file = new File(path);
                uris.add(Uri.fromFile(file));
        }
        intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
        context.startActivity(intent);
    }

Patrón de arranque

Este patrón es un enfoque más estricto para iniciar una Activity . Su propósito es mejorar la legibilidad del código, mientras que al mismo tiempo disminuye la complejidad del código, los costos de mantenimiento y el acoplamiento de sus componentes.

El siguiente ejemplo implementa el patrón de inicio, que generalmente se implementa como un método estático en la propia Activity . Este método estático acepta todos los parámetros requeridos, construye un Intent válido a partir de esos datos y luego inicia la Activity .

Un Intent es un objeto que proporciona un enlace de tiempo de ejecución entre componentes separados, como dos actividades. La intención representa la "intención de hacer algo" de una aplicación. Puede usar los intentos para una amplia variedad de tareas, pero aquí, su intento inicia otra actividad.

public class ExampleActivity extends AppCompatActivity {

    private static final String EXTRA_DATA = "EXTRA_DATA";

    public static void start(Context context, String data) {
        Intent intent = new Intent(context, ExampleActivity.class);
        intent.putExtra(EXTRA_DATA, data);
        context.startActivity(intent);
    }       

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = getIntent();
        if(!intent.getExtras().containsKey(EXTRA_DATA)){
            throw new UnsupportedOperationException("Activity should be started using the static start method");
        }
        String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Este patrón también le permite forzar la transmisión de datos adicionales con la intención.

La actividad de ExampleActivity puede iniciarse así, donde el context es un contexto de actividad:

ExampleActivity.start(context, "Some data!");

Inicia el servicio Unbound usando una intención

Un servicio es un componente que se ejecuta en segundo plano (en el hilo de la interfaz de usuario) sin interacción directa con el usuario. Un servicio no consolidado acaba de iniciarse y no está vinculado al ciclo de vida de ninguna actividad.

Para iniciar un servicio, puede hacer lo que se muestra en el siguiente ejemplo:

// This Intent will be used to start the service
Intent i= new Intent(context, ServiceName.class);
// potentially add data to the intent extras
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i);

Puede usar cualquier extra de la intención utilizando una onStartCommand() :

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            String key1 = extras.getString("KEY1", "");
            if (key1.equals("Value to be used by the service")) {
                //do something
            }
        }
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

Compartir intención

Comparte información simple con diferentes aplicaciones.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to)));

Comparte una imagen con diferentes aplicaciones.

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, getResources().getText(R.string.send_to)));

Iniciar el marcador

Este ejemplo muestra cómo abrir un marcador predeterminado (una aplicación que realiza llamadas regulares) con un número de teléfono proporcionado que ya está en su lugar:

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:9988776655")); //Replace with valid phone number. Remember to add the tel: prefix, otherwise it will crash.
startActivity(intent);

Resultado de ejecutar el código anterior:

Abrir el mapa de Google con la latitud, longitud especificada

Puede pasar latitud, longitud desde su aplicación a Google map usando Intent

String uri = String.format(Locale.ENGLISH, "http://maps.google.com/maps?q=loc:%f,%f", 28.43242324,77.8977673);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
startActivity(intent);

Pasando diferentes datos a través de Intención en Actividad.

1. Pasando datos enteros:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("intVariableName", intValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
int intValue = mIntent.getIntExtra("intVariableName", 0); // set 0 as the default value if no value for intVariableName found

2. Pasando datos dobles:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("doubleVariableName", doubleValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
double doubleValue = mIntent.getDoubleExtra("doubleVariableName", 0.00); // set 0.00 as the default value if no value for doubleVariableName found

3. Pasando datos de la cadena:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("stringVariableName", stringValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
String stringValue = mIntent.getExtras().getString("stringVariableName");

o

Intent mIntent = getIntent();
String stringValue = mIntent.getStringExtra("stringVariableName");

4. Pasando los datos de ArrayList:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putStringArrayListExtra("arrayListVariableName", arrayList);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
arrayList = mIntent.getStringArrayListExtra("arrayListVariableName");

5. Pasando datos del objeto:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("ObjectVariableName", yourObject);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
yourObj = mIntent.getSerializableExtra("ObjectVariableName");

Nota: tenga en cuenta que su clase personalizada debe implementar la interfaz Serializable .

6. Pasando HashMap <String, String> datos:

SenderActivity

HashMap <String, String> hashMap;

Intent mIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
mIntent.putExtra("hashMap", hashMap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();    
HashMap<String, String> hashMap = (HashMap<String, String>)
mIntent.getSerializableExtra("hashMap");

7. Pasando datos de mapa de bits:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("image",bitmap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();
Bitmap bitmap = mIntent.getParcelableExtra("image");

Mostrar un selector de archivos y leer el resultado

Iniciar una actividad de selección de archivos

public void showFileChooser() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);

    // Update with mime types
    intent.setType("*/*");

    // Update with additional mime types here using a String[]. 
    intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);

    // Only pick openable and local files. Theoretically we could pull files from google drive
    // or other applications that have networked files, but that's unnecessary for this example.
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);

    // REQUEST_CODE = <some-integer>
    startActivityForResult(intent, REQUEST_CODE);
}

Leyendo el resultado

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the user doesn't pick a file just return
    if (requestCode != REQUEST_CODE || resultCode != RESULT_OK) {
        return;
    }

    // Import the file
    importFile(data.getData());
}

public void importFile(Uri uri) {
    String fileName = getFileName(uri);

    // The temp file could be whatever you want
    File fileCopy = copyToTempFile(uri, File tempFile)

    // Done!
}

/**
 * Obtains the file name for a URI using content resolvers. Taken from the following link
 * https://developer.android.com/training/secure-file-sharing/retrieve-info.html#RetrieveFileInfo
 *
 * @param uri a uri to query
 * @return the file name with no path
 * @throws IllegalArgumentException if the query is null, empty, or the column doesn't exist
 */
private String getFileName(Uri uri) throws IllegalArgumentException {
    // Obtain a cursor with information regarding this uri
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);

    if (cursor.getCount() <= 0) {
        cursor.close();
        throw new IllegalArgumentException("Can't obtain file name, cursor is empty");
    }

    cursor.moveToFirst();

    String fileName = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));

    cursor.close();

    return fileName;
}

/**
 * Copies a uri reference to a temporary file
 *
 * @param uri      the uri used as the input stream
 * @param tempFile the file used as an output stream
 * @return the input tempFile for convenience
 * @throws IOException if an error occurs
 */
private File copyToTempFile(Uri uri, File tempFile) throws IOException {
    // Obtain an input stream from the uri
    InputStream inputStream = getContentResolver().openInputStream(uri);

    if (inputStream == null) {
        throw new IOException("Unable to obtain input stream from URI");
    }

    // Copy the stream to the temp file
    FileUtils.copyInputStreamToFile(inputStream, tempFile);

    return tempFile;
}

Pasando objeto personalizado entre actividades.

También es posible pasar su objeto personalizado a otras actividades usando la clase Bundle .

Hay dos maneras:

• Interfaz Serializable : para Java y Android
• Interfaz Parcelable : memoria eficiente, solo para Android (recomendado)

Parcelable

El procesamiento parcelable es mucho más rápido que el serializable. Una de las razones de esto es que estamos siendo explícitos sobre el proceso de serialización en lugar de utilizar la reflexión para inferirlo. También es lógico pensar que el código ha sido fuertemente optimizado para este propósito.

public class MyObjects implements Parcelable {
    
    private int age;
    private String name;
    
    private ArrayList<String> address;
    
    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    
    }
    
    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }
    
    public int getAge() {
        return age;
    }
    
    public String getName() {
        return name;
    }
    
    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }
    
    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }
    
        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

Código de actividad de envío

MyObject mObject = new MyObject("name","age","Address array here");

//Passing MyOject 
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObject);
startActivity(mIntent);

Recibiendo el objeto en actividad de destino.

//Getting MyObjects 
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelable("UniqueKey");

Puedes pasar Arraylist of Parceble object como abajo

//Array of MyObjects
ArrayList<MyObject> mUsers;

//Passing MyObject List
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

//Getting MyObject List
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

Nota: Hay complementos de Android Studio como este disponibles para generar código Parcelable

Serializable

Código de actividad de envío

Product product = new Product();
Bundle bundle = new Bundle();
bundle.putSerializable("product", product);
Intent cartIntent = new Intent(mContext, ShowCartActivity.class);
cartIntent.putExtras(bundle);
mContext.startActivity(cartIntent);

Recibiendo el objeto en actividad de destino.

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = this.getIntent().getExtras();
    Product product = null;
    if (bundle != null) {
        product = (Product) bundle.getSerializable("product");
    }

Arraylist of Serializable object: igual que un solo objeto pasando

El objeto personalizado debe implementar la interfaz Serializable .

Obteniendo un resultado de Actividad a Fragmentar

Como obtener un resultado de otra actividad , debe llamar al método Fragment startActivityForResult(Intent intent, int requestCode) . tenga en cuenta que no debe llamar a getActivity().startActivityForResult() ya que esto devolverá el resultado a la Activity principal del Fragment .

La recepción del resultado se puede hacer usando el método de Fragment onActivityResult() . onActivityResult() asegurarse de que la actividad principal del Fragmento también invalida onActivityResult() y llame a la super implementación.

En el siguiente ejemplo, ActivityOne contiene FragmentOne , que iniciará ActivityTwo y esperará un resultado.

ActivityOne

public class ActivityOne extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    // You must override this method as the second Activity will always send its results to this Activity and then to the Fragment
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
    }
}

activity_one.xml

<fragment android:name="com.example.FragmentOne"
    android:id="@+id/fragment_one"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

FragmentOne

public class FragmentOne extends Fragment {
    public static final int REQUEST_CODE = 11;
    public static final int RESULT_CODE = 12;
    public static final String EXTRA_KEY_TEST = "testKey";

    // Initializing and starting the second Activity
    private void startSecondActivity() {
        Intent intent = new Intent(getActivity(), ActivityTwo.class);
        startActivityForResult(REQUEST_CODE, intent);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE && resultCode == RESULT_CODE) {
            String testResult = data.getStringExtra(EXTRA_KEY_TEST);
            // TODO: Do something with your extra data
        }
    }
}

Actividad dos

public class ActivityTwo extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
    }

    private void closeActivity() {
        Intent intent = new Intent();
        intent.putExtra(FragmentOne.EXTRA_KEY_TEST, "Testing passing data back to ActivityOne");
        setResult(FragmentOne.RESULT_CODE, intent); // You can also send result without any data using setResult(int resultCode)
        finish();
    }
}