android.os.FileUriExposedException: file: ///storage/emulated/0/test.txt exposto além do aplicativo por meio de Intent.getData ()

O aplicativo está travando quando estou tentando abrir um arquivo. Funciona abaixo do Android Nougat, mas no Android Nougat ele trava. Ele só trava quando tento abrir um arquivo do cartão SD, não da partição do sistema. Algum problema de permissão?

Código de amostra:

File file = new File("/storage/emulated/0/test.txt");
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(file), "text/*");
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent); // Crashes on this line

Registro:

android.os.FileUriExposedException: file: ///storage/emulated/0/test.txt exposto além do aplicativo por meio de Intent.getData ()

Editar:

Ao segmentar o Android Nougat, os file://URIs não são mais permitidos. Em content://vez disso, devemos usar URIs. No entanto, meu aplicativo precisa abrir arquivos nos diretórios raiz. Alguma ideia?

Se for o seu caso targetSdkVersion >= 24, precisamos usar a FileProviderclasse para conceder acesso ao arquivo ou pasta específico para torná-los acessíveis para outros aplicativos. Criamos nossa própria classe de herança FileProviderpara garantir que o FileProvider não entre em conflito com o FileProviders declarado nas dependências importadas, conforme descrito aqui .

Etapas para substituir o file://URI pelo content://URI:

• Adicionar uma classe estendida FileProvider

  public class GenericFileProvider extends FileProvider {}

• Adicione uma <provider>tag FileProvider na tag AndroidManifest.xmlunder <application>. Especifique uma autoridade exclusiva para o android:authoritiesatributo para evitar conflitos, dependências importadas podem especificar ${applicationId}.providere outras autoridades comumente usadas.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    ...
    <application
        ...
        <provider
            android:name=".GenericFileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/provider_paths"/>
        </provider>
    </application>
</manifest>

• Em seguida, crie um provider_paths.xmlarquivo na res/xmlpasta Pode ser necessário criar uma pasta se ela não existir. O conteúdo do arquivo é mostrado abaixo. Ele descreve que gostaríamos de compartilhar o acesso ao armazenamento externo na pasta raiz (path=".")com o nome external_files .

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path name="external_files" path="."/>
</paths>

• A etapa final é alterar a linha de código abaixo em

  Uri photoURI = Uri.fromFile(createImageFile());

  para

  Uri photoURI = FileProvider.getUriForFile(context, context.getApplicationContext().getPackageName() + ".provider", createImageFile());

• Editar: se você estiver usando a intenção de abrir o arquivo, o sistema poderá ser necessário adicionar a seguinte linha de código:

  intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

Consulte, código completo e solução foram explicados aqui.

Além da solução usando o FileProvider, há outra maneira de contornar isso. Basta colocar

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();
StrictMode.setVmPolicy(builder.build());

no Application.onCreate(). Dessa maneira, a VM ignora a URIexposição do arquivo .

Método

builder.detectFileUriExposure()

ativa a verificação de exposição do arquivo, que também é o comportamento padrão se não configurarmos um VmPolicy.

Eu encontrei um problema que, se eu usar um content:// URIpara enviar algo, alguns aplicativos simplesmente não conseguem entender. E o downgrade da target SDKversão não é permitido. Nesse caso, minha solução é útil.

Atualizar:

Conforme mencionado no comentário, StrictMode é uma ferramenta de diagnóstico e não deve ser usada para esse problema. Quando publiquei esta resposta há um ano, muitos aplicativos só podem receber uris de arquivos. Eles apenas travam quando eu tentei enviar um uri do FileProvider para eles. Isso foi corrigido na maioria dos aplicativos agora; portanto, devemos usar a solução FileProvider.

Se targetSdkVersionfor maior que 24 , o FileProvider é usado para conceder acesso.

Crie um arquivo xml (Caminho: res \ xml) provider_paths.xml

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path name="external_files" path="."/>
</paths>

Adicionar um provedor no AndroidManifest.xml

    <provider
        android:name="android.support.v4.content.FileProvider"
        android:authorities="${applicationId}.provider"
        android:exported="false"
        android:grantUriPermissions="true">
        <meta-data
            android:name="android.support.FILE_PROVIDER_PATHS"
            android:resource="@xml/provider_paths"/>
    </provider>

Se você estiver usando o androidx , o caminho do FileProvider deve ser:

 android:name="androidx.core.content.FileProvider"

e substitua

Uri uri = Uri.fromFile(fileImagePath);

para

Uri uri = FileProvider.getUriForFile(MainActivity.this, BuildConfig.APPLICATION_ID + ".provider",fileImagePath);

Editar: enquanto você estiver incluindo o URI, Intentadicione uma linha abaixo:

intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

e você está pronto para ir. Espero que ajude.

Se seu aplicativo tiver como alvo a API 24+ e você ainda quiser / precisar usar file: // intents, poderá usar a maneira hacky para desativar a verificação de tempo de execução:

if(Build.VERSION.SDK_INT>=24){
   try{
      Method m = StrictMode.class.getMethod("disableDeathOnFileUriExposure");
      m.invoke(null);
   }catch(Exception e){
      e.printStackTrace();
   }
}

O método StrictMode.disableDeathOnFileUriExposureestá oculto e documentado como:

/**
* Used by lame internal apps that haven't done the hard work to get
* themselves off file:// Uris yet.
*/

O problema é que meu aplicativo não é coxo, mas não quer ser aleijado usando content: // intents que não são compreendidos por muitos aplicativos por aí. Por exemplo, abrir arquivo mp3 com o esquema content: // oferece muito menos aplicativos do que abrir o mesmo sobre o arquivo: // esquema. Não quero pagar por falhas de design do Google limitando a funcionalidade do meu aplicativo.

O Google quer que os desenvolvedores usem o esquema de conteúdo, mas o sistema não está preparado para isso. Durante anos, os aplicativos foram feitos para usar Arquivos e não "conteúdo", os arquivos podem ser editados e salvos novamente, enquanto os arquivos veiculados no esquema de conteúdo não podem ser (podem eles?).

Se você targetSdkVersiontem 24 anos ou mais, não é possível usar file: Urivalores nos Intentsdispositivos Android 7.0 ou superior .

Suas escolhas são:

1. Deixe cair targetSdkVersionpara 23 ou menos, ou

2. Coloque seu conteúdo no armazenamento interno e use-oFileProvider para disponibilizá-lo seletivamente para outros aplicativos

Por exemplo:

Intent i=new Intent(Intent.ACTION_VIEW, FileProvider.getUriForFile(this, AUTHORITY, f));

i.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(i);

( deste projeto de amostra )

Primeiro, você precisa adicionar um provedor ao seu AndroidManifest

  <application
    ...>
    <activity>
    .... 
    </activity>
    <provider
        android:name="android.support.v4.content.FileProvider"
        android:authorities="com.your.package.fileProvider"
        android:grantUriPermissions="true"
        android:exported="false">
        <meta-data
            android:name="android.support.FILE_PROVIDER_PATHS"
            android:resource="@xml/file_paths" />
    </provider>
  </application>

agora crie um arquivo na pasta de recursos xml (se estiver usando o android studio, você pode pressionar Alt + Enter após destacar caminhos_do_arquivo e selecionar criar uma opção de recurso xml)

Em seguida, no arquivo file_paths, insira

<?xml version="1.0" encoding="utf-8"?>
<paths>
  <external-path path="Android/data/com.your.package/" name="files_root" />
  <external-path path="." name="external_storage_root" />
</paths>

Este exemplo é para caminho externo, você pode consultar aqui para mais opções. Isso permitirá que você compartilhe arquivos que estão nessa pasta e em sua subpasta.

Agora tudo o que resta é criar a intenção da seguinte maneira:

    MimeTypeMap mime = MimeTypeMap.getSingleton();
    String ext = newFile.getName().substring(newFile.getName().lastIndexOf(".") + 1);
    String type = mime.getMimeTypeFromExtension(ext);
    try {
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_VIEW);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            Uri contentUri = FileProvider.getUriForFile(getContext(), "com.your.package.fileProvider", newFile);
            intent.setDataAndType(contentUri, type);
        } else {
            intent.setDataAndType(Uri.fromFile(newFile), type);
        }
        startActivityForResult(intent, ACTIVITY_VIEW_ATTACHMENT);
    } catch (ActivityNotFoundException anfe) {
        Toast.makeText(getContext(), "No activity found to open this attachment.", Toast.LENGTH_LONG).show();
    }

EDIT : eu adicionei a pasta raiz do cartão sd no file_paths. Eu testei esse código e ele funciona.

A resposta do @palash k está correta e funcionou para arquivos de armazenamento interno, mas, no meu caso, também quero abrir arquivos do armazenamento externo, meu aplicativo travou quando o arquivo foi aberto do armazenamento externo, como sdcard e usb, mas consegui resolver o problema modificando provider_paths.xml da resposta aceita

altere o provider_paths.xml como abaixo

<?xml version="1.0" encoding="utf-8"?>
 <paths xmlns:android="http://schemas.android.com/apk/res/android">

<external-path path="Android/data/${applicationId}/" name="files_root" />

<root-path
    name="root"
    path="/" />

</paths>

e na classe java (nenhuma alteração, pois a resposta aceita é apenas uma pequena edição)

Uri uri=FileProvider.getUriForFile(getActivity(), BuildConfig.APPLICATION_ID+".provider", File)

Isso me ajuda a corrigir a falha de arquivos de armazenamentos externos. Espero que isso ajude alguém com o mesmo problema que o meu :)

Minha solução foi 'Uri.parse' o caminho do arquivo como String, em vez de usar Uri.fromFile ().

String storage = Environment.getExternalStorageDirectory().toString() + "/test.txt";
File file = new File(storage);
Uri uri;
if (Build.VERSION.SDK_INT < 24) {
    uri = Uri.fromFile(file);
} else {
    uri = Uri.parse(file.getPath()); // My work-around for new SDKs, doesn't work in Android 10.
}
Intent viewFile = new Intent(Intent.ACTION_VIEW);
viewFile.setDataAndType(uri, "text/plain");
startActivity(viewFile);

Parece que fromFile () usa um ponteiro de arquivo, que suponho que pode ser inseguro quando endereços de memória são expostos a todos os aplicativos. Mas Um caminho de arquivo String nunca prejudica ninguém, por isso funciona sem lançar FileUriExposedException.

Testado nos níveis de API 9 a 27! Abre com êxito o arquivo de texto para edição em outro aplicativo. Não requer o FileProvider, nem a Biblioteca de Suporte do Android.

Basta colar o código abaixo na atividade onCreate ()

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder(); StrictMode.setVmPolicy(builder.build());

Ele ignorará a exposição ao URI

Basta colar o código abaixo na atividade onCreate().

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder(); 
StrictMode.setVmPolicy(builder.build());

Ele ignorará a exposição ao URI.

Happy coding :-)

Usar o fileProvider é o caminho a percorrer. Mas você pode usar esta solução alternativa simples:

AVISO : será corrigido na próxima versão do Android - https://issuetracker.google.com/issues/37122890#comment4

substituir:

startActivity(intent);

de

startActivity(Intent.createChooser(intent, "Your title"));

Eu usei a resposta de Palash dada acima, mas estava um pouco incompleta, tive que fornecer permissão como esta

Intent intent = new Intent(Intent.ACTION_VIEW);
    Uri uri;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        uri = FileProvider.getUriForFile(this, getPackageName() + ".provider", new File(path));

        List<ResolveInfo> resInfoList = getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
        for (ResolveInfo resolveInfo : resInfoList) {
            String packageName = resolveInfo.activityInfo.packageName;
            grantUriPermission(packageName, uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
        }
    }else {
        uri = Uri.fromFile(new File(path));
    }

    intent.setDataAndType(uri, "application/vnd.android.package-archive");

    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    startActivity(intent);

Basta colar o código abaixo na atividade onCreate ()

Construtor StrictMode.VmPolicy.Builder = new StrictMode.VmPolicy.Builder (); StrictMode.setVmPolicy (builder.build ());

Ele ignorará a exposição ao URI

adicione essas duas linhas no onCreate

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();
    StrictMode.setVmPolicy(builder.build());

Método de compartilhamento

File dir = new File(Environment.getExternalStorageDirectory(), "ColorStory");
File imgFile = new File(dir, "0.png");
Intent sendIntent = new Intent(Intent.ACTION_VIEW);
sendIntent.setType("image/*");
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://" + imgFile));
sendIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(Intent.createChooser(sendIntent, "Share images..."));

Aqui está a minha solução:

no Manifest.xml

<application
            android:name=".main.MainApp"
            android:allowBackup="true"
            android:icon="@drawable/ic_app"
            android:label="@string/application_name"
            android:logo="@drawable/ic_app_logo"
            android:theme="@style/MainAppBaseTheme">

        <provider
                android:name="androidx.core.content.FileProvider"
                android:authorities="${applicationId}.provider"
                android:exported="false"
                android:grantUriPermissions="true">
            <meta-data
                    android:name="android.support.FILE_PROVIDER_PATHS"
                    android:resource="@xml/provider_paths"/>
        </provider>

em res / xml / provider_paths.xml

   <?xml version="1.0" encoding="utf-8"?>
    <paths xmlns:android="http://schemas.android.com/apk/res/android">
        <external-path name="external_files" path="."/>
    </paths>

no meu fragmento eu tenho o próximo código:

 Uri myPhotoFileUri = FileProvider.getUriForFile(getActivity(), getActivity().getApplicationContext().getPackageName() + ".provider", myPhotoFile);               
    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, myPhotoFileUri);

É tudo o que você precisa.

Também não precisa criar

public class GenericFileProvider extends FileProvider {}

Eu testo no Android 5.0, 6.0 e Android 9.0 e é um trabalho bem-sucedido.

Para baixar pdf do servidor, adicione o código abaixo na sua classe de serviço. Espero que isso seja útil para você.

File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), fileName + ".pdf");
    intent = new Intent(Intent.ACTION_VIEW);
    //Log.e("pathOpen", file.getPath());

    Uri contentUri;
    contentUri = Uri.fromFile(file);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);

    if (Build.VERSION.SDK_INT >= 24) {

        Uri apkURI = FileProvider.getUriForFile(context, context.getApplicationContext().getPackageName() + ".provider", file);
        intent.setDataAndType(apkURI, "application/pdf");
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

    } else {

        intent.setDataAndType(contentUri, "application/pdf");
    }

E sim, não esqueça de adicionar permissões e provedor no seu manifesto.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

<application

<provider
        android:name="android.support.v4.content.FileProvider"
        android:authorities="${applicationId}.provider"
        android:exported="false"
        android:grantUriPermissions="true">
        <meta-data
            android:name="android.support.FILE_PROVIDER_PATHS"
            android:resource="@xml/provider_paths" />
    </provider>

</application>

Não sei por que, fiz tudo exatamente igual ao Pkosta ( https://stackoverflow.com/a/38858040 ), mas continuava recebendo erro:

java.lang.SecurityException: Permission Denial: opening provider redacted from ProcessRecord{redacted} (redacted) that is not exported from uid redacted

Eu perdi horas nessa questão. O culpado? Kotlin.

val playIntent = Intent(Intent.ACTION_VIEW, uri)
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)

intentestava realmente definindo em getIntent().addFlagsvez de operar no meu recém-declarado playIntent.

Eu coloquei esse método para que o caminho imageuri entre facilmente no conteúdo.

enter code here
public Uri getImageUri(Context context, Bitmap inImage)
{
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    inImage.compress(Bitmap.CompressFormat.PNG, 100, bytes);
    String path = MediaStore.Images.Media.insertImage(context.getContentResolver(), 
    inImage, "Title", null);
    return Uri.parse(path);
}

As of Android N, in order to work around this issue, you need to use the FileProvider API

Existem três etapas principais aqui, conforme mencionado abaixo

Etapa 1: Entrada do manifesto

<manifest ...>
    <application ...>
        <provider
            android:name="android.support.v4.content.FileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/provider_paths"/>
        </provider>
    </application>
</manifest>

Etapa 2: criar o arquivo XML res / xml / provider_paths.xml

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path name="external_files" path="."/>
</paths>

Etapa 3: alterações de código

File file = ...;
Intent install = new Intent(Intent.ACTION_VIEW);
install.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
// Old Approach
    install.setDataAndType(Uri.fromFile(file), mimeType);
// End Old approach
// New Approach
    Uri apkURI = FileProvider.getUriForFile(
                             context, 
                             context.getApplicationContext()
                             .getPackageName() + ".provider", file);
    install.setDataAndType(apkURI, mimeType);
    install.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
// End New Approach
    context.startActivity(install);

Sei que essa é uma pergunta bastante antiga, mas essa resposta é para futuros telespectadores. Então, eu encontrei um problema semelhante e, depois de pesquisar, encontrei uma alternativa para essa abordagem.

Sua intenção aqui, por exemplo: Para visualizar sua imagem do seu caminho no Kotlin

 val intent = Intent()
 intent.setAction(Intent.ACTION_VIEW)
 val file = File(currentUri)
 intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
 val contentURI = getContentUri(context!!, file.absolutePath)
 intent.setDataAndType(contentURI,"image/*")
 startActivity(intent)

Função principal abaixo

private fun getContentUri(context:Context, absPath:String):Uri? {
        val cursor = context.getContentResolver().query(
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
            arrayOf<String>(MediaStore.Images.Media._ID),
            MediaStore.Images.Media.DATA + "=? ",
            arrayOf<String>(absPath), null)
        if (cursor != null && cursor.moveToFirst())
        {
            val id = cursor.getInt(cursor.getColumnIndex(MediaStore.MediaColumns._ID))
            return Uri.withAppendedPath(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, Integer.toString(id))
        }
        else if (!absPath.isEmpty())
        {
            val values = ContentValues()
            values.put(MediaStore.Images.Media.DATA, absPath)
            return context.getContentResolver().insert(
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
        }
        else
        {
            return null
        }
    }

Da mesma forma, em vez de uma imagem, você pode usar qualquer outro formato de arquivo, como pdf, e no meu caso, funcionou bem

Passei quase um dia tentando descobrir por que estava recebendo essa exceção. Após muita luta, essa configuração funcionou perfeitamente ( Kotlin ):

AndroidManifest.xml

<provider
  android:name="androidx.core.content.FileProvider"
  android:authorities="com.lomza.moviesroom.fileprovider"
  android:exported="false"
  android:grantUriPermissions="true">
  <meta-data
    android:name="android.support.FILE_PROVIDER_PATHS"
    android:resource="@xml/file_paths" />
</provider>

file_paths.xml

<?xml version="1.0" encoding="utf-8"?>
<paths>
  <files-path name="movies_csv_files" path="."/>
</paths>

Intenção em si

fun goToFileIntent(context: Context, file: File): Intent {
    val intent = Intent(Intent.ACTION_VIEW)
    val contentUri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
    val mimeType = context.contentResolver.getType(contentUri)
    intent.setDataAndType(contentUri, mimeType)
    intent.flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION

    return intent
}

Eu explico todo o processo aqui .

https://stackoverflow.com/a/38858040/395097, esta resposta está completa.

Esta resposta é para: você já tem um aplicativo com segmentação abaixo de 24 e agora está atualizando para targetSDKVersion> = 24.

No Android N, apenas o URL do arquivo exposto ao aplicativo de terceiros é alterado. (Não da maneira que estávamos usando antes). Altere apenas os lugares em que você está compartilhando o caminho com o aplicativo de terceiros (câmera no meu caso)

Em nosso aplicativo, estávamos enviando uri para o aplicativo Câmera. Nesse local, esperamos que o aplicativo da câmera armazene a imagem capturada.

1. Para o Android N, geramos um novo conteúdo: // URL baseado em uri apontando para o arquivo.
2. Geramos o caminho usual da API de arquivo para o mesmo (usando o método mais antigo).

Agora, temos 2 uri diferentes para o mesmo arquivo. O nº 1 é compartilhado com o aplicativo Câmera. Se a intenção da câmera for bem sucedida, podemos acessar a imagem do item 2.

Espero que isto ajude.

Xamarin.Android

Nota: O caminho xml / provider_paths.xml (.axml) não pôde ser resolvido, mesmo depois de criar a pasta xml em Resources (talvez ela possa ser colocada em um local existente como Values , não tentei), por isso recorri a isso que funciona por enquanto. Os testes mostraram que ele só precisa ser chamado uma vez por execução do aplicativo (o que faz sentido, pois altera o estado operacional da VM do host).

Nota: o xml precisa ser capitalizado, portanto, Resources / Xml / provider_paths.xml

Java.Lang.ClassLoader cl = _this.Context.ClassLoader;
Java.Lang.Class strictMode = cl.LoadClass("android.os.StrictMode");                
System.IntPtr ptrStrictMode = JNIEnv.FindClass("android/os/StrictMode");
var method = JNIEnv.GetStaticMethodID(ptrStrictMode, "disableDeathOnFileUriExposure", "()V");                
JNIEnv.CallStaticVoidMethod(strictMode.Handle, method);

A resposta da @Pkosta é uma maneira de fazer isso.

Além de usar FileProvider, você também pode inserir o arquivo MediaStore(especialmente para arquivos de imagem e vídeo), porque os arquivos no MediaStore são acessíveis a todos os aplicativos:

O MediaStore é voltado principalmente para os tipos MIME de vídeo, áudio e imagem; no entanto, a partir do Android 3.0 (nível 11 da API), ele também pode armazenar tipos que não sejam de mídia (consulte MediaStore.Files para obter mais informações). Os arquivos podem ser inseridos no MediaStore usando scanFile (), após o qual um conteúdo: // estilo Uri adequado para compartilhamento é passado para o retorno de chamada onScanCompleted () fornecido. Observe que, uma vez adicionado ao MediaStore do sistema, o conteúdo fica acessível para qualquer aplicativo no dispositivo.

Por exemplo, você pode inserir um arquivo de vídeo no MediaStore assim:

ContentValues values = new ContentValues();
values.put(MediaStore.Video.Media.DATA, videoFilePath);
Uri contentUri = context.getContentResolver().insert(
      MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values);

contentUrié como content://media/external/video/media/183473, que pode ser passado diretamente para Intent.putExtra:

intent.setType("video/*");
intent.putExtra(Intent.EXTRA_STREAM, contentUri);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
activity.startActivity(intent);

Isso funciona para mim e economiza os aborrecimentos de usar FileProvider.

Simplesmente deixe-o ignorar a exposição do URI ... Adicione-o após a criação

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder(); StrictMode.setVmPolicy(builder.build()); 

Experimente esta solução

COLOCAR ESTAS PERMISSÕES EM MANIFESTO

 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 <uses-permission android:name="android.permission.CAMERA" />

INTENÇÃO DE CAPTURAR IMAGEM

Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
                    startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
                }

OBTENHA IMAGEM CAPTURADA EM RESULTADO DA ATIVIDADE

@Override
            protected void onActivityResult(int requestCode, int resultCode, Intent data) {
                super.onActivityResult(requestCode, resultCode, data);
                if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
                    Bundle extras = data.getExtras();
                    Bitmap imageBitmap = (Bitmap) extras.get("data");
                    // CALL THIS METHOD TO GET THE URI FROM THE BITMAP
                    Uri tempUri = getImageUri(getApplicationContext(), imageBitmap);
                    //DO SOMETHING WITH URI
                }
            } 

MÉTODO PARA OBTER URI DE IMAGEM

public Uri getImageUri(Context inContext, Bitmap inImage) {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
        String path = MediaStore.Images.Media.insertImage(inContext.getContentResolver(), inImage, "Title", null);
        return Uri.parse(path);
    }

No meu caso, me livrei da exceção substituindo SetDataAndTypepor just SetData.