Alguns idiomas comuns de Intent no Android, como enviar mensagens de texto, enviar e-mails, iniciar a câmera para tirar fotos e gravar vídeos, definir o alarme, abrir a interface de configuração WIFI, etc.
Índice
enviar mensagens
Ao enviar uma mensagem de texto, a ação que queremos usar é Intent.ACTION_SENDTO, e seu URI deve ser especificado como o smsto: protocolo, para garantir que o aplicativo de mensagem de texto receba e processe nosso objeto de intenção, não outros aplicativos, para para enviar mensagens de texto com precisão. Se nossa ação não for Intent.ACTION_SENDTO, mas Intent.ACTION_SEND, e o URI do protocolo smsto: não for especificado, o Android não iniciará diretamente o aplicativo SMS após receber o objeto de intenção, mas abrirá o Seletor de aplicativos, deixe Podemos escolher qual aplicativo iniciar, como e-mail, QQ etc., portanto, para garantir que o aplicativo SMS seja iniciado diretamente, devemos usar Intent.ACTION_SENDTO e especificar o URI do protocolo smsto:.
O código de exemplo é o seguinte:
// Use ACTION_SENDTO em vez de ACTION_SEND
Intenção intenção = nova Intenção(Intenção.ACTION_SENDTO);
//Especifica a URI para usar o smsto: protocolo, seguido do objeto para receber o SMS
Uri uri = Uri.parse("smsto:10086");
intent.setData(uri);
//Define o corpo da mensagem
intent.putExtra("sms_body", "O dinheiro está um pouco apertado, por favor, pegue algum dinheiro emprestado~~");
ComponentName componentName = intent.resolveActivity(getPackageManager());
if(componentName != null){
startActivity(intenção);
}
Ao construir o URI para enviar mensagens de texto, a frente é o protocolo smsto:, seguido do número do celular da outra parte que está recebendo a mensagem de texto. Se você escrever apenas smsto: ao construir o URI, mas não escrever o número do celular atrás, a intenção também pode iniciar o aplicativo SMS com sucesso, mas, neste caso, depois de iniciar o aplicativo SMS, precisamos inseri-lo novamente por nós mesmos Insira manualmente o número do celular para receber a mensagem. Definimos o conteúdo do SMS para o extra de sms_body através da chave.
Vale ressaltar que após a execução do startActivity(intent), embora o aplicativo SMS seja iniciado, o SMS não é enviado diretamente, sendo necessário clicar para enviar a mensagem novamente.
enviar email
Ao enviar e-mails, a ação que queremos usar também é Intent.ACTION_SENDTO, e seu URI deve ser especificado como o protocolo mailto:, para garantir que o aplicativo de e-mail receba e processe nosso objeto de intenção, não outros aplicativos, para enviar e-mails com precisão o objetivo de. Se nossa ação não for Intent.ACTION_SENDTO, mas Intent.ACTION_SEND, e o URI do protocolo mailto: não for especificado, o Android não enviará o aplicativo por e-mail diretamente após receber o objeto de intenção, mas exibirá o Seletor de aplicativos, deixe-nos escolha Qual aplicativo iniciar, como SMS, QQ etc., portanto, para garantir que o aplicativo de e-mail seja iniciado diretamente, devemos usar Intent.ACTION_SENDTO e especificar o URI do protocolo mailto:.
O código de exemplo é o seguinte:
// Use ACTION_SENDTO em vez de ACTION_SEND
Intenção intenção = nova Intenção(Intenção.ACTION_SENDTO);
// Especifique o URI para usar o protocolo mailto: para garantir que apenas o aplicativo de email possa receber esse objeto de intenção
Uri uri = Uri.parse("mailto:");
intent.setData(uri);
String[] endereços = {"[email protected]", "[email protected]"};
String[] cc = {"[email protected]"};
String[] bcc = {"[email protected]"};
String assunto = "Horas extras";
String content = "Dia Nacional para trabalhar normalmente~~";
//Define o destinatário do e-mail
intent.putExtra(Intent.EXTRA_EMAIL, endereços);
//Definir a parte cc do e-mail
intent.putExtra(Intent.EXTRA_CC, cc);
//Define a parte bcc do e-mail
intent.putExtra(Intent.EXTRA_BCC, bcc);
//Define o título do e-mail
intent.putExtra(Intent.EXTRA_SUBJECT, assunto);
//Configura o conteúdo do e-mail
intent.putExtra(Intent.EXTRA_TEXT, conteúdo);
//Definir anexos de e-mail
//intent.putExtra(Intent.EXTRA_STREAM, Uri.parse(...));
ComponentName componentName = intent.resolveActivity(getPackageManager());
if(componentName != null){
startActivity(intenção);
}
Uma captura de tela após o lançamento do aplicativo Mail é mostrada abaixo:
Definimos o destinatário, CC e BCC do e-mail em sequência através dos extras cujas chaves são Intent.EXTRA_EMAIL, Intent.EXTRA_CC e Intent.EXTRA_BCC, e seus valores são todos arrays String. Definimos o título do email para o extra de Intent.EXTRA_SUBJECT por meio da chave e definimos o conteúdo do email para o extra de Intent.EXTRA_TEXT por meio da chave. Se você deseja enviar um anexo, pode encapsular o anexo na forma de Uri e, em seguida, definir o anexo de e-mail para o extra de Intent.EXTRA_STREAM por meio da chave.
Deve-se observar que após startActivity(intent) ser executado, embora o aplicativo de e-mail seja iniciado e aberto, o e-mail não é enviado diretamente e precisamos clicar no botão enviar no canto superior direito para enviar o e-mail.
Ligue
Para fazer uma chamada por Intent, temos duas ações que podem ser utilizadas: Intent.ACTION_DIAL e Intent.ACTION_CALL, existem algumas diferenças entre as duas.
Se você usar Intent.ACTION_DIAL como a ação do objeto de intenção, quando startActivity(intent) for executado, o aplicativo de chamada será iniciado e o número do celular especificado será inserido automaticamente, mas não será discado automaticamente. precisa pressionar manualmente o botão de discagem para realmente chamar a outra parte.
Se Intent.ACTION_CALL for usado como a ação do objeto intent, depois que startActivity(intent) for executado, o aplicativo de chamada será iniciado e o número de telefone especificado será discado diretamente, sem a necessidade de pressionar manualmente o botão de discagem. No entanto, deve-se observar que esta ação requer a permissão android.permission.CALL_PHONE. Se esta permissão não for adicionada ao arquivo AndroidManifest.xml do aplicativo, quando o código startActivity(intent) for especificado, uma exceção será lançada O aplicativo falha e sai.
Aqui está o código de amostra:
//Intent.ACTION_DIAL disca apenas, não chama
//Intenção intent = new Intent(Intent.ACTION_DIAL);
//Intent.ACTION_CALL disca diretamente para o telefone especificado, requer permissão android.permission.CALL_PHONE
Intenção intenção = new Intenção(Intenção.ACTION_CALL);
Uri uri = Uri.parse("tel:10086");
intent.setData(uri);
ComponentName componentName = intent.resolveActivity(getPackageManager());
if(componentName != null){
startActivity(intenção);
}
Neste código de amostra, usamos Intent.ACTION_CALL como a ação do objeto de intenção e adicionamos as seguintes permissões em AndroidManifest.xml:
<uses-permission android:name="android.permission.CALL_PHONE"></uses-permission>
Usamos o URI do protocolo tel:, o número a ser discado está atrás do protocolo e o Uri é usado como os dados do objeto de intenção.
Fotografia
Para iniciar a câmera para tirar fotos através do Intent, precisamos definir o valor da ação do objeto intent para a ação de MediaStore.ACTION_IMAGE_CAPTURE. Em seguida, usamos a chave para definir o caminho de saída da imagem para o extra de MediaStore.EXTRA_OUTPUT e, finalmente, chamamos o método startActivityForResult() para iniciar o aplicativo da câmera e reescrevemos nosso onActivityResult() para que possamos saber que a foto é tomadas neste método.
O código de exemplo é o seguinte:
//Indica o requestCode usado para tirar fotos
int final privado REQUEST_CODE_IMAGE_CAPTURE = 1;
//Armazenamos o caminho de saída da foto para uso posterior
uri privado imageOutputUri = null;
//Fotografia
private void captureImage(){
PackageManager pm = getPackageManager();
//Primeiro determine se a máquina tem capacidade de câmera no hardware
if(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)){
Intenção intenção = nova Intenção(MediaStore.ACTION_IMAGE_CAPTURE);
ComponentName componentName = intent.resolveActivity(pm);
//Determina se existe um aplicativo de câmera no celular
if(componentName != null){
//Cria um arquivo de imagem para que o Uri correspondente possa ser gerado através do Uri.fromFile()
Arquivo imageFile = createImageFile();
if(imageFile != null){
//Gerar o Uri correspondente de acordo com imageFile
imageOutputUri = Uri.fromFile(imageFile);
//Use este Uri como o caminho de armazenamento da foto após a foto ser tirada. Observe que uma vez que o caminho de armazenamento é definido, não podemos obter a miniatura
intent.putExtra(MediaStore.EXTRA_OUTPUT, imageOutputUri);
//Chame o método startActivityForResult() para processamento correspondente no método onActivityResult()
startActivityForResult(intenção, REQUEST_CODE_IMAGE_CAPTURE);
}outro{
Toast.makeText(this, "Não foi possível criar arquivo de imagem!", Toast.LENGTH_LONG).show();
}
}outro{
Toast.makeText(this, "O aplicativo da câmera não pode ser encontrado nesta máquina, não é possível tirar fotos!", Toast.LENGTH_LONG).show();
}
}outro{
Toast.makeText(this, "Esta máquina não tem câmera e não pode tirar fotos!", Toast.LENGTH_LONG).show();
}
}
//Cria um arquivo de imagem para que o Uri correspondente possa ser gerado através do Uri.fromFile()
Arquivo privado createImageFile(){
Imagem do arquivo = null;
// Costure o nome do arquivo com o carimbo de data/hora para evitar a duplicação do arquivo
String timeStamp = new SimpleDateFormat("aaaaMMdd_HHmmss").format(new Date());
String imageFileName = "JPEG_" + timeStamp + "_";
Arquivo storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
tentar{
imagem = Arquivo.createTempFile(
imageFileName, //prefixo
".jpg", //sufixo
storageDir //pasta
);
}catch (IOException e){
imagem = null;
e.printStackTrace();
Log.e("DemoLog", e.getMessage());
}
imagem de retorno;
}
@Sobrepor
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
// primeiro determina se foi concluído corretamente
if(resultCode == RESULT_OK){
switch (requestCode){
caso REQUEST_CODE_IMAGE_CAPTURE:
//Aqui, podemos obter a imagem que queremos através de imageOutputUri
String imagePath = imageOutputUri.toString();
Log.i("DemoLog", "O caminho da foto é: " + imagePath);
Toast.makeText(this, "O caminho da foto é: " + imagePath, Toast.LENGTH_LONG).show();
//O código a seguir tenta obter a miniatura
//Se MediaStore.EXTRA_OUTPUT for definido como extra, então a intenção aqui é nula e precisa ser julgada
if(intenção != null){
Miniatura de bitmap = intent.getParcelableExtra("dados");
//Alguns telefones celulares não geram miniaturas para fotos tiradas, então julgue aqui
if(miniatura != null){
Log.i("DemoLog", "Obter thumbnail");
}
}
padrão:
quebrar;
}
}
}
Vamos analisar o trecho de código acima:
Nem todos os dispositivos Android podem tirar fotos, então primeiro chamamos o método hasSystemFeature(PackageManager.FEATURE_CAMERA) de PackageManager para determinar se o dispositivo atual tem a capacidade de tirar fotos no nível do hardware.
Em seguida, criamos um objeto de intenção cuja ação é MediaStore.ACTION_IMAGE_CAPTURE.
Em seguida, chamamos o método intent.resolveActivity(pm) para determinar se o dispositivo atual possui um aplicativo de câmera para que possamos iniciá-lo. Se não houver aplicativo de câmera, mas passarmos o objeto de intenção para startActivity() ou startActivityForResult(), uma exceção será lançada e o aplicativo travará e será encerrado.
Nós mesmos escrevemos um método createImageFile, através do qual criamos um arquivo de imagem no cartão de memória periférico correspondente ao nosso aplicativo. Vale ressaltar que esta etapa requer a permissão WRITE_EXTERNAL_STORAGE, que está registrada no AndroidManifest.xml da seguinte forma:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="18"></uses-permission>
Consulte WRITE_EXTERNAL_STORAGE para obter mais informações sobre essa permissão.
Usamos o arquivo de imagem gerado acima para gerar o Uri correspondente, armazenamos no campo imageOutputUri do tipo Uri na Activity, e então executamos intent.putExtra(MediaStore.EXTRA_OUTPUT, imageOutputUri), e usamos este Uri como a foto após o a foto é tirada caminho de armazenamento. O que precisa de atenção especial aqui é que, uma vez que o caminho de armazenamento é definido, não podemos obter a miniatura em onActivityResult().
Por fim, precisamos chamar o método startActivityForResult(intent, REQUEST_CODE_IMAGE_CAPTURE) para iniciar o aplicativo da câmera para tirar fotos, onde REQUEST_CODE_IMAGE_CAPTURE é nosso requestCode especificado personalizado para tirar fotos.
Sobrescrevemos o método onActivityResult e acionamos a execução desse método após a captura das fotos. Em primeiro lugar, precisamos julgar se o resultCode é igual a RESULT_OK. Somente se for igual, significa que a foto foi tirada com sucesso. Em seguida, julgamos se o requestCode é igual a REQUEST_CODE_IMAGE_CAPTURE. Se for igual, significa que é o resultado retornado pela foto. Então, neste momento, podemos obter as fotos que acabamos de tirar através do imageOutputUri que armazenamos antes, e sua string de URI é como: file:///storage/sdcard0/Android/data/com.ispring.commonintents/files/Pictures/ JPEG_20150919_112704_533002075.jpg
Deve-se observar que, se definirmos MediaStore.EXTRA_OUTPUT como o caminho de saída da foto na etapa 5, o Intent retornado do aplicativo da câmera não poderá ser obtido em onActivityResult, que é nulo, portanto, a miniatura não poderá ser obtida. Por outro lado, se MediaStore.EXTRA_OUTPUT não for definido como o caminho de saída da foto na etapa 5, a intenção não está vazia, você pode tentar executar Bitmap thumbnail = intent.getParcelableExtra("data") para obter a miniatura, se a miniatura não estiver vazio, significa sucesso Obtenha uma miniatura. No entanto, alguns telefones celulares não geram miniaturas para as fotos tiradas, portanto, a miniatura aqui também pode ser nula, portanto, julgue antes de usá-la.
Câmera
As etapas para iniciar a câmera para tirar fotos pelo Intent são muito semelhantes às etapas para iniciar a câmera para tirar fotos pelo Intent mencionado acima, com pequenas diferenças. Para iniciar a câmera para gravação de vídeo, precisamos definir a ação com o valor de MediaStore.ACTION_VIDEO_CAPTURE para o intent, em seguida, usamos a chave para definir o caminho de saída da imagem para o extra de MediaStore.EXTRA_OUTPUT e, finalmente, chamar o startActivityForResult() para iniciar o aplicativo da câmera e reescrever nosso onActivityResult() para saber que a câmera está completa neste método.
Aqui está o código de amostra:
//Indica o requestCode usado para gravar o vídeo
final privado int REQUEST_CODE_VIDEO_CAPTURE = 2;
//Armazenamos o caminho de saída do vídeo para uso posterior
uri privado videoOutputUri = null;
//Câmera
private void captureVideo(){
PackageManager pm = getPackageManager();
//Primeiro determine se a máquina tem capacidade de câmera no hardware
if(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)){
//Defina a ação da intenção para MediaStore.ACTION_VIDEO_CAPTURE
Intenção intenção = nova Intenção(MediaStore.ACTION_VIDEO_CAPTURE);
ComponentName componentName = intent.resolveActivity(pm);
//Determina se existe um aplicativo de câmera no celular
if(componentName != null){
//Cria um arquivo de vídeo para que o Uri correspondente possa ser gerado através do Uri.fromFile()
Arquivo videoFile = createVideoFile();
if(videoFile != null){
//Gerar o Uri correspondente de acordo com videoFile
videoOutputUri = Uri.fromFile(videoFile);
//Use este Uri como o caminho de armazenamento do vídeo após a conclusão da câmera
intent.putExtra(MediaStore.EXTRA_OUTPUT, videoOutputUri);
//Chame o método startActivityForResult() para processamento correspondente no método onActivityResult()
startActivityForResult(intenção, REQUEST_CODE_VIDEO_CAPTURE);
}outro{
Toast.makeText(this, "Não foi possível criar arquivo de vídeo!", Toast.LENGTH_LONG).show();
}
}outro{
Toast.makeText(this, "O aplicativo da câmera não pode ser encontrado nesta máquina, não é possível gravar!", Toast.LENGTH_LONG).show();
}
}outro{
Toast.makeText(this, "Esta máquina não tem câmera, não pode tirar fotos!", Toast.LENGTH_LONG).show();
}
}
//Cria um arquivo de vídeo para que o Uri correspondente possa ser gerado através do Uri.fromFile()
arquivo privado createVideoFile(){
Arquivo videoArquivo = null;
// Costure o nome do arquivo com o carimbo de data/hora para evitar a duplicação do arquivo
String timeStamp = new SimpleDateFormat("aaaaMMdd_HHmmss").format(new Date());
String imageFileName = "MP4" + timeStamp + "_";
Arquivo storageDir = getExternalFilesDir(Environment.DIRECTORY_MOVIES);
tentar{
videoArquivo = Arquivo.createTempFile(
imageFileName, //prefixo
".mp4", //sufixo
storageDir //pasta
);
}catch (IOException e){
videoArquivo = null;
e.printStackTrace();
Log.e("DemoLog", e.getMessage());
}
return videoArquivo;
}
@Sobrepor
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
// primeiro determina se foi concluído corretamente
if(resultCode == RESULT_OK){
switch (requestCode){
caso REQUEST_CODE_VIDEO_CAPTURE:
//Se MediaStore.EXTRA_OUTPUT for definido como extra,
//Em alguns celulares, a intenção aqui não é nula, mas em alguns celulares é nula,
//Portanto, não é recomendado obter o caminho do vídeo de intent.getData()
//Devemos gravar videoOutputUri sozinhos para saber o caminho do vídeo, o código comentado abaixo não é recomendado
/*if(intenção != null){
Uri videoUri = intent.getData();
if (videoUri != null){
//Formato do caminho, como content://media/external/video/media/130025
Log.i("DemoLog", "O caminho do vídeo é: " + videoUri.toString());
}
}*/
String videoPath = videoOutputUri.toString();
//1. Se MediaStore.EXTRA_OUTPUT não for definido como o caminho de armazenamento do arquivo de vídeo, o formato do caminho será o seguinte:
// formato de caminho como content://media/external/video/media/130025
//2. Se MediaStore.EXTRA_OUTPUT for definido como o caminho de armazenamento do arquivo de vídeo, o formato do caminho será o seguinte:
// Formato de caminho como file:///storage/sdcard0/Android/data/com.ispring.commonintents/files/Movies/MP420150919_184132_533002075.mp4
Log.i("DemoLog", "O caminho do vídeo é: " + videoPath);
Toast.makeText(this, "O caminho do vídeo é: " + videoPath, Toast.LENGTH_LONG).show();
quebrar;
padrão:
quebrar;
}
}
}
Você pode ver que o código acima para iniciar a câmera é quase igual ao código para tirar fotos. Para obter detalhes, consulte a descrição do código da câmera. Neste código de amostra, definimos o caminho de armazenamento do vídeo por meio de MediaStore.EXTRA_OUTPUT e também definimos o caminho de saída da foto por meio dele ao tirar fotos, mas os dois são ligeiramente diferentes:
-
Para tirar fotos, depois que MediaStore.EXTRA_OUTPUT é definido, o parâmetro Intent em onActivityResult é nulo e o caminho de armazenamento da foto não pode ser obtido do Intent.
-
Para a câmera, depois que MediaStore.EXTRA_OUTPUT é definido, o parâmetro Intent em onActivityResult é nulo em alguns telefones celulares, mas não nulo em alguns telefones celulares. O objeto de intenção obtido pelo meu celular Mi 1s não é nulo, por isso é muito estranho aqui . Se a intenção não for nula, você pode obter o caminho de armazenamento do arquivo de vídeo por meio de intent.getData(), mas como não há certeza se a intenção é nula, tente não obter seu caminho por meio do método intent.getData(), mas armazená-lo no campo Activity One contém o caminho do arquivo que definimos anteriormente, então está tudo bem.