Algunas expresiones comunes de Intent en Android, como enviar mensajes de texto, enviar correos electrónicos, encender la cámara para tomar fotos y grabar videos, configurar la alarma, abrir la interfaz de configuración de WIFI, etc. a través de Intent.
Tabla de contenido
enviar mensajes
Al enviar un mensaje de texto, la acción que queremos usar es Intent.ACTION_SENDTO, y su URI debe especificarse como el protocolo smsto: para garantizar que la aplicación de mensajes de texto reciba y procese nuestro objeto de intención, no otras aplicaciones, para que en cuanto a enviar con precisión mensajes de texto el objetivo de. Si nuestra acción no es Intent.ACTION_SENDTO, sino Intent.ACTION_SEND, y no se especifica la URI del protocolo smsto:, entonces Android no iniciará directamente la aplicación de SMS después de recibir el objeto de intención, sino que abrirá el Selector de aplicaciones, deje nosotros elegimos qué aplicación iniciar, como correo electrónico, QQ, etc., por lo que para garantizar que la aplicación de SMS se inicie directamente, debemos usar Intent.ACTION_SENDTO y especificar el URI del protocolo smsto:.
El código de ejemplo es el siguiente:
//Usar ACTION_SENDTO en lugar de ACTION_SEND
Intención intent = new Intent(Intent.ACTION_SENDTO);
//Especifique la URI para usar el protocolo smsto: seguido del objeto que recibe SMS
Uri uri = Uri.parse("smsto:10086");
intent.setData(uri);
//Establece el cuerpo del mensaje
intent.putExtra("sms_body", "Estoy un poco apretado, pide prestado algo de dinero~~");
ComponentName
nombre del componente = intent.resolveActivity(getPackageManager());
if(componentName != null){
startActivity(intent);
}
Al construir la URI para enviar mensajes de texto, el frente es el protocolo smsto:, seguido del número de teléfono móvil de la otra parte que recibe el mensaje de texto. Si solo escribe smsto: al construir el URI, pero no escribe el número de teléfono móvil detrás, entonces la intención también puede iniciar con éxito la aplicación de SMS, pero en este caso, después de iniciar la aplicación de SMS, debemos volver a ingresarla por nosotros mismos Introduzca manualmente el número de teléfono móvil para recibir el mensaje. Configuramos el contenido del SMS para el extra de sms_body a través de la clave.
Cabe señalar que después de ejecutar startActivity(intent), aunque se inicia la aplicación de SMS, el SMS no se envía directamente y debemos hacer clic para enviar el mensaje nuevamente.
enviar correo electrónico
Al enviar correos electrónicos, la acción que queremos usar también es Intent.ACTION_SENDTO, y su URI debe especificarse como el protocolo mailto: para garantizar que la aplicación de correo reciba y procese nuestro objeto de intención, no otras aplicaciones, para enviar con precisión correos electrónicos con el objetivo de. Si nuestra acción no es Intent.ACTION_SENDTO, sino Intent.ACTION_SEND, y no se especifica el URI del protocolo mailto:, entonces Android no enviará directamente la aplicación por correo después de recibir el objeto de intención, sino que abrirá el Selector de aplicaciones, permítanos Elija qué aplicación iniciar, como SMS, QQ, etc., por lo que para garantizar que la aplicación de correo se inicie directamente, debemos usar Intent.ACTION_SENDTO y especificar el URI del protocolo mailto:.
El código de ejemplo es el siguiente:
//Usar ACTION_SENDTO en lugar de ACTION_SEND
Intento = nuevo Intento(Intento.ACTION_SENDTO);
//Especifique el URI para usar el protocolo mailto: para garantizar que solo la aplicación de correo pueda recibir este objeto de intención
Uri uri = Uri.parse("mailto :");
intent.setData(uri);
String[] direcciones = {"[email protected]", "[email protected]"};
String[] cc = {"[email protected]"};
String [] bcc = {"[email protected]"};
String subject = "Hora extra";
String content = "Trabajo normal del Día Nacional~~";
//Establecer el destinatario del correo electrónico
intent.putExtra(Intent.EXTRA_EMAIL, direcciones );
//Establecer el correo electrónico La intención de la parte de copia carbón.putExtra
(Intent.EXTRA_CC, cc);
//Establecer la parte de copia oculta de la intención del correo
electrónico.putExtra(Intent.EXTRA_BCC, bcc);
//Establecer la
intención del título del correo electrónico .putExtra(Intent.EXTRA_SUBJECT, asunto);
//Establecer el contenido del correo electrónico
intent.putExtra(Intent.EXTRA_TEXT, content);
//Establecer archivos adjuntos de correo electrónico
//intent.putExtra(Intent.EXTRA_STREAM, Uri.parse(...));
ComponentName nombre del componente = intent.resolveActivity(getPackageManager());
if( nombre del componente != null){
startActivity(intención);
}
A continuación se muestra una captura de pantalla después de iniciar la aplicación Mail:
Establecemos el destinatario, CC y BCC del correo electrónico en secuencia a través de los extras cuyas claves son Intent.EXTRA_EMAIL, Intent.EXTRA_CC e Intent.EXTRA_BCC, y sus valores son todos matrices de cadenas. Establecemos el título del correo para el extra de Intent.EXTRA_SUBJECT a través de la clave, y establecemos el contenido del correo para el extra de Intent.EXTRA_TEXT a través de la clave. Si desea enviar un archivo adjunto, puede encapsular el archivo adjunto en forma de Uri y luego configurar el archivo adjunto de correo electrónico para el extra de Intent.EXTRA_STREAM a través de la clave.
Cabe señalar que después de ejecutar startActivity(intent), aunque se inicia y abre la aplicación de correo, el correo no se envía directamente, y debemos hacer clic en el botón Enviar en la esquina superior derecha para enviar el correo.
Llamar
Para realizar una llamada a través de Intent, tenemos dos acciones que se pueden usar: Intent.ACTION_DIAL e Intent.ACTION_CALL, existen ciertas diferencias entre los dos.
Si usa Intent.ACTION_DIAL como la acción del objeto de intención, cuando se ejecute startActivity(intent), se iniciará la aplicación de llamadas y el número de teléfono móvil especificado se ingresará automáticamente, pero no se marcará automáticamente. necesita presionar manualmente el botón de marcar para realmente llamar a la otra parte.
Si se usa Intent.ACTION_CALL como la acción del objeto de intención, luego de ejecutar startActivity(intent), se iniciará la aplicación de llamada y se marcará directamente el número de teléfono que especificamos, sin que tengamos que presionar manualmente el botón de marcación. Sin embargo, debe tenerse en cuenta que esta acción requiere el permiso android.permission.CALL_PHONE. Si este permiso no se agrega en el archivo AndroidManifest.xml de la aplicación, cuando se especifique el código startActivity(intent), se generará una excepción. La aplicación falla y se cierra.
Aquí hay un código de muestra:
//Intent.ACTION_DIAL solo marca, no llama
//Intent Intent = new Intent(Intent.ACTION_DIAL);
//Intent.ACTION_CALL marca directamente el teléfono especificado, requiere el permiso android.permission.CALL_PHONE
Intent Intent = new Intent(Intent.ACTION_CALL );
Uri uri = Uri.parse("tel:10086");
intent.setData(uri);
ComponentName nombre del componente = intent.resolveActivity(getPackageManager());
if(componentName != null){
startActivity(intent);
}
En este código de muestra, usamos Intent.ACTION_CALL como la acción del objeto de intención y agregamos los siguientes permisos en AndroidManifest.xml:
<usos-permiso android:name="android.permiso.CALL_PHONE"></usos-permiso>
Usamos el URI del protocolo tel:, el número a marcar está detrás del protocolo y el Uri se usa como los datos del objeto de intención.
Fotografía
Para que la cámara comience a tomar fotografías a través de Intent, debemos establecer el valor de acción del objeto de intención en la acción de MediaStore.ACTION_IMAGE_CAPTURE. Luego usamos la tecla para establecer la ruta de salida de la imagen para el extra de MediaStore.EXTRA_OUTPUT, y finalmente llamamos al método startActivityForResult() para iniciar la aplicación de la cámara, y reescribimos nuestro onActivityResult() para que podamos saber que la foto es tomado en este método.
El código de ejemplo es el siguiente:
//representa el código de solicitud
private final int REQUEST_CODE_IMAGE_CAPTURE = 1;
//almacenamos la ruta de salida de la foto para su uso posterior
private Uri imageOutputUri = null;
//tomar una foto
private void captureImage(){
PackageManager pm = getPackageManager()
;
/ /Primero determine si la máquina tiene capacidad de cámara en el hardware
if(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)){
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
ComponentName nombre del componente = intent.resolveActivity(pm);
//Determinar el móvil phone No hay una aplicación de cámara
if(componentName != null){
//Cree un archivo de imagen para que el
archivo Uri correspondiente pueda generarse a través de Uri.fromFile() imageFile = createImageFile();
if(imageFile != null){
//Generar el Uri correspondiente de acuerdo con imageFile
imageOutputUri = Uri.fromFile(imageFile);
//Usar este Uri como la ruta de almacenamiento de la foto después de tomarla Tenga en cuenta que una vez que se establece la ruta de almacenamiento, no podemos obtener la miniatura .intent.putExtra
( MediaStore.EXTRA_OUTPUT, imageOutputUri);
//Llame al método startActivityForResult() para el procesamiento correspondiente en el método onActivityResult()
startActivityForResult(intent, REQUEST_CODE_IMAGE_CAPTURE);
}else{
Toast.makeText(this, "El archivo de imagen no puede crearse!", Toast .LENGTH_LONG).show();
}
}else{
Toast.makeText(esto, "No se puede encontrar la aplicación de la cámara en esta máquina, ¡no se pueden tomar fotos!", Toast.LENGTH_LONG).show(); } }
más
{
Toast.makeText(this, "¡Esta máquina no tiene cámara y no puede tomar fotos!", Toast.LENGTH_LONG).show(); } //
Crea
}
un archivo de imagen para que el
archivo privado de Uri correspondiente pueda generarse a través de Uri. fromFile() createImageFile() {
Imagen de archivo = nulo;
//
Concatenar nombres de archivo con marcas de tiempo para evitar nombres de archivo duplicados
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
String imageFileName = "JPEG_" + timeStamp + "_ ";
File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
pruebe
{
image = File.createTempFile(
imageFileName, //prefijo
".jpg", //sufijo
storageDir //carpeta
);
}atrapar (IOException e){
image = null;
e.printStackTrace();
Log.e("DemoLog", e.getMessage());
}
return
image;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
//Primero juzgue si se completó correctamente
if(resultCode == RESULT_OK){
switch (requestCode){
case REQUEST_CODE_IMAGE_CAPTURE :
// Aquí, podemos obtener la imagen que queremos a través de imageOutputUri
String imagePath = imageOutputUri.toString();
Log.i("DemoLog", "La ruta de la foto es: " + imagePath);
Toast.makeText(this, "Photo La ruta es: " + imagePath, Toast.LENGTH_LONG).show();
//
El siguiente código intenta obtener la miniatura " +
imagePath ,
Toast.LENGTH_LONG
Miniatura de mapa de bits = intento.getParcelableExtra ("datos");
//Algunos teléfonos móviles no generan miniaturas de las imágenes tomadas, por lo que también es necesario juzgar
if(miniatura != null){
Log.i
("DemoLog", "Get thumbnails");
}
}
default:
break;
} }
}
Analicemos el fragmento de código anterior:
No todos los dispositivos Android pueden tomar fotografías, por lo que primero llamamos al método hasSystemFeature(PackageManager.FEATURE_CAMERA) de PackageManager para determinar si el dispositivo actual tiene la capacidad de tomar fotografías a nivel de hardware.
Luego creamos un objeto de intención cuya acción es MediaStore.ACTION_IMAGE_CAPTURE.
Luego llamamos al método intent.resolveActivity(pm) para determinar si el dispositivo actual tiene una aplicación de cámara para que podamos iniciarla. Si no hay una aplicación de cámara pero pasamos el objeto de intención a startActivity() o startActivityForResult(), se generará una excepción y la aplicación se bloqueará y se cerrará.
Nosotros mismos escribimos un método createImageFile, a través del cual creamos un archivo de imagen en la tarjeta de memoria periférica correspondiente a nuestra aplicación. Cabe señalar que este paso requiere el permiso WRITE_EXTERNAL_STORAGE, el cual se encuentra registrado en AndroidManifest.xml de la siguiente manera:
<usos-permiso android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="18"></usos-permiso>
Consulte WRITE_EXTERNAL_STORAGE para obtener más información sobre este permiso.
Usamos el archivo de imagen generado arriba para generar el Uri correspondiente, lo almacenamos en el campo imageOutputUri de tipo Uri en la Actividad, y luego ejecutamos intent.putExtra(MediaStore.EXTRA_OUTPUT, imageOutputUri), y usamos este Uri como la foto después del la foto se toma ruta de almacenamiento. Lo que necesita atención especial aquí es que una vez que se establece la ruta de almacenamiento, no podemos obtener la miniatura en onActivityResult().
Finalmente, necesitamos llamar al método startActivityForResult(intent, REQUEST_CODE_IMAGE_CAPTURE) para iniciar la aplicación de la cámara para tomar fotografías, donde REQUEST_CODE_IMAGE_CAPTURE es nuestro código de solicitud especificado personalizado para tomar fotografías.
Anulamos el método onActivityResult y activamos la ejecución de este método después de tomar fotografías. En primer lugar, debemos juzgar si el código de resultado es igual a RESULT_OK. Solo si es igual, significa que la foto se tomó con éxito. Luego, juzgamos si el código de solicitud es igual a SOLICITUD_CÓDIGO_IMAGE_CAPTURE. Si es igual, significa que es el resultado devuelto por la foto. Luego, en este momento, podemos obtener las fotos que acabamos de tomar a través de imageOutputUri que almacenamos antes, y su cadena URI es como: file:///storage/sdcard0/Android/data/com.ispring.commonintents/files/Pictures/ JPEG_20150919_112704_533002075.jpg
Cabe señalar que si configuramos MediaStore.EXTRA_OUTPUT como la ruta de salida de la foto en el paso 5, la intención devuelta por la aplicación de la cámara no se puede obtener en onActivityResult, que es nulo, por lo que no se puede obtener la miniatura. Por el contrario, si MediaStore.EXTRA_OUTPUT no se configura como la ruta de salida de la foto en el paso 5, la intención no está vacía, puede intentar ejecutar Bitmap thumbnail = intent.getParcelableExtra("data") para obtener la miniatura, si la miniatura no está vacío, significa éxito Obtener una miniatura. Sin embargo, algunos teléfonos móviles no generan miniaturas para las imágenes tomadas, por lo que la miniatura aquí también puede ser nula, así que juzgue antes de usarla.
cámara
Los pasos para iniciar la cámara para tomar fotografías a través de Intent son muy similares a los pasos para iniciar la cámara para tomar fotografías a través de Intent que se acaban de mencionar, con ligeras diferencias. Para iniciar la cámara para la grabación de video, debemos configurar la acción con el valor de MediaStore.ACTION_VIDEO_CAPTURE para la intención, luego usamos la tecla para configurar la ruta de salida de la imagen para el extra de MediaStore.EXTRA_OUTPUT, y finalmente llamamos a la startActivityForResult() para iniciar la aplicación de la cámara y reescriba nuestro onActivityResult() para saber que la cámara está completa en este método.
Aquí hay un código de muestra:
//Indica el código de solicitud
private final int REQUEST_CODE_VIDEO_CAPTURE = 2;
//Almacenamos la ruta de salida del video para uso posterior
private Uri videoOutputUri = null;
//
Camera
private void captureVideo(){
PackageManager pm = getPackageManager() ;
/ /
Primero determine si la máquina tiene capacidad de cámara en el hardware
if(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)){
//Establezca la acción de la intención en MediaStore.ACTION_VIDEO_CAPTURE
Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
ComponentName componentName = intent.resolveActivity(pm);
//Determina si hay una aplicación de cámara en el teléfono
if(componentName != null){
//Crea un archivo de video para que el Uri correspondiente pueda generarse a través de Uri.fromFile()
File videoFile = createVideoFile();
if(videoFile != null){
//Generar el Uri correspondiente de acuerdo con videoFile
videoOutputUri = Uri.fromFile(videoFile);
//Usar este Uri como la ruta de almacenamiento del video después de disparar
intent.putExtra (MediaStore .EXTRA_OUTPUT, videoOutputUri);
//Llame al método startActivityForResult() para el procesamiento correspondiente en el método onActivityResult()
startActivityForResult(intent, REQUEST_CODE_VIDEO_CAPTURE);
}else{
Toast.makeText(this, "¡No se puede crear el archivo de video!", Toast. LENGTH_LONG).show();
}
}else{
Toast.makeText(esto, "¡La aplicación de la cámara no se encuentra en esta máquina, no se puede grabar!", Toast.LENGTH_LONG).show();
}
{
Toast.makeText(this, "¡Esta máquina no tiene cámara, por lo que no puede tomar un video!", Toast.LENGTH_LONG).show(); } } // Crea
un
archivo
de
video para que el Uri correspondiente
El archivo privado createVideoFile se puede generar a través de Uri.fromFile() (){
File videoFile = null;
//
Concatene los nombres de archivo con marcas de tiempo para evitar nombres de archivo duplicados
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date() );
String imageFileName = "MP4" + timeStamp + "_";
File storageDir = getExternalFilesDir(Environment.DIRECTORY_MOVIES);
prueba
{
videoFile = File.createTempFile(
imageFileName, //prefijo
".mp4",//sufijo
storageDir //carpeta
);
}catch (IOException e){
//Deberíamos registrar el videoOutputUri para conocer la ruta del video, el código comentado a continuación es uso no recomendado
videoFile = null;
e.printStackTrace();
Log.e("DemoLog", e.getMessage());
}
return
videoFile;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
// Primero juzgue si se completó correctamente
if(resultCode == RESULT_OK){
switch (requestCode){
case REQUEST_CODE_VIDEO_CAPTURE:
//Si MediaStore.EXTRA_OUTPUT se configura como extra,
//en algunos teléfonos móviles, la intención aquí no es nula, pero sí es nulo en algunos teléfonos móviles,
//por lo que no se recomienda obtener la ruta del video desde intent.getData()
/*if(intent != null){
Uri videoUri = intent.getData();
if(videoUri != null){
//Formato de ruta como content://media/external/video/media/130025
Log.i( " DemoLog", "La ruta del video es: " + videoUri.toString()); } }
*
/
String
videoPath = videoOutputUri.toString();
//1. Si MediaStore.EXTRA_OUTPUT no está configurado como la ruta de almacenamiento del archivo de video , luego el formato de la ruta como se muestra a continuación:
// El formato de la ruta es content://media/external/video/media/130025
// 2. Si MediaStore.EXTRA_OUTPUT se configura como la ruta de almacenamiento del archivo de video, el formato de la ruta es como sigue:
// Formato de ruta como file:///storage/sdcard0/Android/data/com.ispring.commonintents/files/Movies/MP420150919_184132_533002075.mp4
Log.i("DemoLog", "La ruta del video es: " + videoPath );
Toast.makeText(esto, "La ruta del video es: " + videoPath, Toast. LENGTH_LONG) .show();
romper;
predeterminado:
romper;
}
}
}
Puede ver que el código anterior para iniciar la cámara es casi el mismo que el código para tomar fotografías. Para obtener más información, consulte la descripción del código de la cámara. En este código de muestra, configuramos la ruta de almacenamiento del video a través de MediaStore.EXTRA_OUTPUT, y también configuramos la ruta de salida de la foto a través de él cuando tomamos fotos, pero las dos son ligeramente diferentes:
-
Para tomar fotos, después de configurar MediaStore.EXTRA_OUTPUT, el parámetro Intent en onActivityResult es nulo y la ruta de almacenamiento de la foto no se puede obtener del Intent.
-
Para la cámara, después de configurar MediaStore.EXTRA_OUTPUT, el parámetro Intent en onActivityResult es nulo en algunos teléfonos móviles, pero no es nulo en algunos teléfonos móviles. El objeto de intención obtenido por mi teléfono móvil Mi 1s no es nulo, por lo que es muy extraño aquí . Si la intención no es nula, puede obtener la ruta de almacenamiento del archivo de video a través de intent.getData(), pero debido a que no está claro si la intención es nula, intente no obtener su ruta a través del método intent.getData(), pero guárdelo en el campo Actividad Uno contiene la ruta del archivo que establecimos anteriormente, por lo que está bien.