android.os.FileUriExposedException: file: ///storage/emulated/0/test.txt esposto oltre l'app tramite Intent.getData ()

L'app si arresta in modo anomalo quando provo ad aprire un file. Funziona sotto Android Nougat, ma su Android Nougat si arresta in modo anomalo. Si arresta in modo anomalo solo quando provo ad aprire un file dalla scheda SD, non dalla partizione di sistema. Qualche problema di autorizzazione?

Codice di esempio:

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

log:

android.os.FileUriExposedException: file: ///storage/emulated/0/test.txt esposto oltre l'app tramite Intent.getData ()

Modificare:

Quando si sceglie come target Android Nougat, gli file://URI non sono più consentiti. Dovremmo usare content://invece gli URI. Tuttavia, la mia app deve aprire i file nelle directory principali. Qualche idea?

Se il tuo targetSdkVersion >= 24, allora dobbiamo usare la FileProviderclasse per dare accesso a un determinato file o cartella per renderli accessibili per altre app. Creiamo la nostra eredità di classe FileProviderper assicurarci che il nostro FileProvider non sia in conflitto con FileProviders dichiarati nelle dipendenze importate come descritto qui .

Passaggi per sostituire file://URI con content://URI:

• Aggiungi una classe che si estende FileProvider

  public class GenericFileProvider extends FileProvider {}

• Aggiungi un <provider>tag FileProvider AndroidManifest.xmlsotto il <application>tag. Specificare un'autorità unica per l' android:authoritiesattributo per evitare conflitti, le dipendenze importate potrebbero specificare ${applicationId}.providere altre autorità comunemente utilizzate.

<?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>

• Quindi creare un provider_paths.xmlfile nella res/xmlcartella. La cartella potrebbe essere necessaria per la creazione se non esiste. Il contenuto del file è mostrato di seguito. Descrive che vorremmo condividere l'accesso alla memoria esterna nella cartella principale (path=".")con il 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>

• Il passaggio finale consiste nel modificare la riga di codice di seguito in

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

  per

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

• Modifica: se stai usando un intento per rendere il sistema aperto il tuo file, potrebbe essere necessario aggiungere la seguente riga di codice:

  intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

Si prega di fare riferimento, il codice completo e la soluzione sono stati spiegati qui.

Oltre alla soluzione che utilizza il FileProvider, esiste un altro modo per aggirare questo. In poche parole

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

in Application.onCreate(). In questo modo la VM ignora l' URIesposizione dei file .

Metodo

builder.detectFileUriExposure()

abilita il controllo dell'esposizione dei file, che è anche il comportamento predefinito se non configuriamo un VmPolicy.

Ho riscontrato un problema che, se utilizzo a content:// URIper inviare qualcosa, alcune app non riescono a capirlo. E il downgrade della target SDKversione non è consentito. In questo caso la mia soluzione è utile.

Aggiornare:

Come menzionato nel commento, StrictMode è uno strumento diagnostico e non dovrebbe essere utilizzato per questo problema. Quando ho pubblicato questa risposta un anno fa, molte app possono ricevere solo file uris. Si arrestano in modo anomalo quando provo a inviare loro un uri FileProvider. Questo problema è stato risolto nella maggior parte delle app ora, quindi dovremmo andare con la soluzione FileProvider.

Se targetSdkVersionè maggiore di 24 , FileProvider viene utilizzato per concedere l'accesso.

Creare un file xml (Path: 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>

Aggiungi un provider in 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 stai usando androidx , il percorso di FileProvider dovrebbe essere:

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

e sostituisci

Uri uri = Uri.fromFile(fileImagePath);

per

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

Modifica: mentre includi l'URI con una Intentassicurati di aggiungere la riga sotto:

intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

e sei a posto. Spero che sia d'aiuto.

Se la tua app è indirizzata all'API 24+ e desideri / hai ancora bisogno di utilizzare intenti file: //, puoi utilizzare il modo hacky per disabilitare il controllo di runtime:

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

Il metodo StrictMode.disableDeathOnFileUriExposureè nascosto e documentato come:

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

Il problema è che la mia app non è zoppa, ma piuttosto non vuole essere paralizzata usando content: // intenti che non sono compresi da molte app là fuori. Ad esempio, l'apertura di un file mp3 con contenuto: // schema offre molte meno app rispetto all'apertura dello stesso su file: // schema. Non voglio pagare per i difetti di progettazione di Google limitando la funzionalità della mia app.

Google vuole che gli sviluppatori utilizzino lo schema dei contenuti, ma il sistema non è preparato per questo, per anni le app sono state create per utilizzare File non "contenuti", i file possono essere modificati e salvati, mentre i file pubblicati sullo schema dei contenuti non possono essere (può essi?).

Se hai targetSdkVersion24 anni o più, non puoi utilizzare i file: Urivalori Intentssui dispositivi Android 7.0+ .

Le tue scelte sono:

1. Rilascia il numero targetSdkVersiona 23 o inferiore, oppure

2. Metti i tuoi contenuti nella memoria interna, quindi usaliFileProvider per renderli disponibili in modo selettivo ad altre app

Per esempio:

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

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

(da questo progetto di esempio )

Per prima cosa devi aggiungere un provider al tuo 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>

ora crea un file nella cartella delle risorse xml (se usi Android Studio puoi premere Alt + Invio dopo aver evidenziato i percorsi_file e selezionare l'opzione Crea risorsa xml)

Successivamente, immettere il file file_paths

<?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>

Questo esempio è per percorso esterno che puoi consultare qui per ulteriori opzioni. Questo ti permetterà di condividere i file che si trovano in quella cartella e nella sua sottocartella.

Ora non resta che creare l'intento come segue:

    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 : ho aggiunto la cartella principale della scheda SD nei file_paths. Ho testato questo codice e funziona.

La risposta di @palash k è corretta e ha funzionato per i file di memoria interna, ma nel mio caso voglio aprire anche i file da memoria esterna, la mia app si è arrestata in modo anomalo quando il file aperto da memoria esterna come sdcard e usb, ma riesco a risolvere il problema modificando provider_paths.xml dalla risposta accettata

cambia provider_paths.xml come di seguito

<?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 in classe java (nessuna modifica come risposta accettata solo una piccola modifica)

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

Questo mi aiuta a risolvere il crash dei file da archivi esterni, spero che questo possa aiutare qualcuno che ha lo stesso problema del mio :)

La mia soluzione era "Uri.parse" il percorso del file come stringa, invece di utilizzare 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);

Sembra che fromFile () utilizzi un puntatore a file, che suppongo potrebbe essere insicuro quando gli indirizzi di memoria sono esposti a tutte le app. Ma un percorso di file String non fa mai male a nessuno, quindi funziona senza lanciare FileUriExposedException.

Testato sui livelli API da 9 a 27! Apre correttamente il file di testo per la modifica in un'altra app. Non richiede FileProvider, né la libreria di supporto Android.

Basta incollare il codice seguente in attività onCreate ()

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

Ignorerà l'esposizione all'URI

Basta incollare il codice qui sotto in attività onCreate().

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

Ignorerà l'esposizione all'URI.

Buona codifica :-)

L'uso di fileProvider è la strada da percorrere. Ma puoi usare questa semplice soluzione alternativa:

ATTENZIONE : verrà risolto nella prossima versione di Android - https://issuetracker.google.com/issues/37122890#comment4

sostituire:

startActivity(intent);

di

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

Ho usato la risposta di Palash di cui sopra, ma era in qualche modo incompleta, ho dovuto fornire un permesso come questo

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 incollare il codice seguente in attività onCreate ()

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

Ignorerà l'esposizione all'URI

aggiungi queste due righe in onCreate

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

Condividi metodo

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

Ecco la mia soluzione:

in 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>

in 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>

nel mio frammento ho il seguente codice:

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

È tutto ciò di cui hai bisogno.

Inoltre non è necessario creare

public class GenericFileProvider extends FileProvider {}

Ho testato su Android 5.0, 6.0 e Android 9.0 ed è successo.

Per scaricare pdf dal server, aggiungi il codice seguente nella tua classe di servizio. Spero che questo ti sia utile.

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 sì, non dimenticare di aggiungere permessi e provider nel tuo manifest.

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

Non so perché, ho fatto tutto esattamente come Pkosta ( https://stackoverflow.com/a/38858040 ) ma continuavo a ricevere errori:

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

Ho perso ore su questo problema. Il colpevole? Kotlin.

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

intentstava effettivamente impostando getIntent().addFlagsinvece di operare sul mio playIntent appena dichiarato.

ho inserito questo metodo in modo che il percorso di imageuri ottenga facilmente contenuti.

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

Ci sono 3 passaggi principali qui come indicato di seguito

Passaggio 1: inserimento manifest

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

Passaggio 2: creare il file 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>

Passaggio 3: modifiche al codice

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

So che questa è una domanda piuttosto vecchia ma questa risposta è per i futuri spettatori. Quindi ho riscontrato un problema simile e dopo le ricerche, ho trovato un'alternativa a questo approccio.

Il tuo intento qui per esempio: per visualizzare la tua immagine dal tuo percorso in 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)

Funzione principale di seguito

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
        }
    }

Allo stesso modo, invece di un'immagine, puoi usare qualsiasi altro formato di file come pdf e nel mio caso, ha funzionato bene

Ho trascorso quasi un giorno a cercare di capire perché stavo ottenendo questa eccezione. Dopo molte lotte, questa configurazione ha funzionato perfettamente ( 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>

Intento stesso

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
}

Spiego l'intero processo qui .

https://stackoverflow.com/a/38858040/395097 questa risposta è completa.

Questa risposta è per: hai già un'app con targeting inferiore a 24 e ora stai eseguendo l'upgrade a targetSDKVersion> = 24.

In Android N, viene modificato solo il file uri esposto all'app di terze parti. (Non come lo usavamo prima). Quindi cambia solo i luoghi in cui condividi il percorso con un'app di terze parti (Fotocamera nel mio caso)

Nella nostra app stavamo inviando uri all'app Fotocamera, in quella posizione ci aspettiamo che l'app Fotocamera memorizzi l'immagine catturata.

1. Per Android N, generiamo un nuovo URL basato su Content: // uri che punta al file.
2. Generiamo il solito percorso basato su File API per lo stesso (usando il metodo più vecchio).

Ora abbiamo 2 diversi uri per lo stesso file. Il numero 1 è condiviso con l'app Fotocamera. Se l'intento della fotocamera ha esito positivo, possiamo accedere all'immagine dal numero 2.

Spero che sia di aiuto.

Xamarin.Android

Nota: il percorso xml / provider_paths.xml (.axml) non può essere risolto, anche dopo aver creato la cartella xml in Risorse (forse può essere inserita in una posizione esistente come Valori , non ho provato), quindi ho fatto ricorso a questo che funziona per ora. I test hanno dimostrato che deve essere chiamato solo una volta per ogni esecuzione dell'applicazione (il che ha senso in quanto modifica lo stato operativo della VM host).

Nota: xml deve essere in maiuscolo, quindi Risorse / 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);

La risposta di @Pkosta è un modo per farlo.

Oltre all'utilizzo FileProvider, puoi anche inserire il file in MediaStore(specialmente per file di immagini e video), poiché i file in MediaStore sono accessibili a tutte le app:

MediaStore si rivolge principalmente ai tipi MIME di video, audio e immagini, tuttavia a partire da Android 3.0 (livello API 11) può anche memorizzare tipi non multimediali (vedere File MediaStore.File per ulteriori informazioni). I file possono essere inseriti nel MediaStore usando scanFile () dopo di che un Uri di tipo: // style adatto alla condivisione viene passato al callback onScanCompleted () fornito. Nota che una volta aggiunto al sistema MediaStore il contenuto è accessibile a qualsiasi app sul dispositivo.

Ad esempio, è possibile inserire un file video in MediaStore in questo modo:

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

contentUriè come content://media/external/video/media/183473, che può essere passato direttamente a Intent.putExtra:

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

Questo funziona per me e salva le seccature dell'uso FileProvider.

Lascia che ignori l'esposizione URI ... Aggiungilo dopo aver creato

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

Prova questa soluzione

METTERE QUESTE AUTORIZZAZIONI AL MANIFESTO

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

INTENSO PER CATTURARE IMMAGINE

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

OTTIENI IMMAGINI CATTURATE IN RISULTATO ONATTIVITÀ

@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
                }
            } 

METODO PER OTTENERE L'URI DI IMMAGINE

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

Nel mio caso mi sono sbarazzato dell'eccezione sostituendolo SetDataAndTypecon just SetData.