How to request fs permission in Android?

[SANDIXST]

Okay, so you've added the necessary permissions to your AndroidManifest.xml:

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

But on recent Android versions, this doesn't work, and you need to request permission at runtime. I couldn't find the answer in the Tauri documentation.

[XCLHove]

I also have the same question.

[Iaphetes]

I also want to push this question.
I'm using Android 14 and Tauri 2.
I've tried the same as the op but cannot access files. At least not from html code. ConvertFileSrc generates the correct URL but file access is not requested.
Can anyone help?

[alvindimas05]

This is how I did it on my project based on tauri geolocation plugin. In my case, it requested READ_MEDIA_AUDIO permission. If you want to see my project codes, click here.

• Change directory to src-tauri (ex. cd src-tauri)
• Create a new plugin project using npx or whatever js runtime you have

npx @tauri-apps/cli plugin new [yourappname]

• There will be a new project called "tauri-plugin-yourappname"
• In your Cargo.toml, add "specta" to the dependencies and add "specta" to "tauri" features. It should look like this.

[dependencies]
tauri = { version = "2.1.0", features = ["specta"] }
specta = "=2.0.0-rc.20"

• Add this code in your models.rs. Change the Audio type to whatever you need.

use serde::{Deserialize, Serialize};
use tauri::plugin::PermissionState;
use specta::Type;

#[derive(Debug, Clone, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct PermissionStatus {
    pub audio: PermissionState,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum PermissionType {
    Audio,
}

• Add this code inside the impl of file mobile.rs

impl<R: Runtime> YourApp<R> {
    pub fn check_permissions(&self) -> crate::Result<PermissionStatus> {
        self.0
            .run_mobile_plugin("checkPermissions", ())
            .map_err(Into::into)
    }

    pub fn request_permissions(
        &self,
        permissions: Option<Vec<PermissionType>>,
    ) -> crate::Result<PermissionStatus> {
        self.0
            .run_mobile_plugin(
                "requestPermissions",
                serde_json::json!({ "permissions": permissions }),
            )
            .map_err(Into::into)
    }
}

• Add the commands into the commands.rs

#[cfg(mobile)]
use tauri::{AppHandle, Runtime};
#[cfg(mobile)]
use crate::models::*;
#[cfg(mobile)]
use crate::YourAppExt;
#[cfg(mobile)]
use crate::Result;

#[cfg(mobile)]
#[tauri::command]
#[specta::specta]
pub(crate) async fn check_permissions<R: Runtime>(app: AppHandle<R>) -> Result<PermissionStatus> {
    app.yourapp().check_permissions()
}

#[cfg(mobile)]
#[tauri::command]
#[specta::specta]
pub(crate) async fn request_permissions<R: Runtime>(
    app: AppHandle<R>,
    permissions: Option<Vec<PermissionType>>,
) -> Result<PermissionStatus> {
    app.yourapp().request_permissions(permissions)
}

• Add the commands into the invoke_handler on lib.rs. It should look like this.

pub fn init<R: Runtime>() -> TauriPlugin<R> {
    Builder::new("yourappname")
        .invoke_handler(tauri::generate_handler![
            // Your Commands
            #[cfg(mobile)]
            commands::check_permissions,
            #[cfg(mobile)]
            commands::request_permissions,
        ])
        .setup(|app, api| {
            #[cfg(mobile)]
            let yourapp = mobile::init(app, api)?;
            #[cfg(desktop)]
            let yourapp = desktop::init(app, api)?;
            app.manage(yourapp);
            Ok(())
        })
        .build()
}

• Oh and don't forget to add pub to the mod models at the lib.rs because we need that later.

pub mod models;

Oh well, that's a lot of code. Also, A lot of #[cfg(mobile)]. We are done on the rust part. Now for the kotlin part.

• Add this code at YourAppActivity.kt and it should look something like this

import app.tauri.annotation.Permission
import android.Manifest

// Replace the alias with other name
private const val ALIAS_READ_AUDIO: String = "audio"
@TauriPlugin(
    permissions = [
        Permission(strings = [
            // Change with other permissions
            Manifest.permission.READ_MEDIA_AUDIO
        ],
            alias = ALIAS_READ_AUDIO
        )
    ]
)
class YourAppPlugin(private val activity: Activity): Plugin(activity) {
    // The rest of the codes...
}

I guess that's it folks. We can call it now in our Rust code. This is the example. (Idk how you get the AppHandle but I'm using the global method)

#[cfg(mobile)]
#[tauri::command]
pub fn request_read_audio_permission() -> bool {
    use crate::GLOBAL_APP_HANDLE;
    use tauri::plugin::PermissionState;
    use tauri_plugin_yourapp::models::PermissionType;
    use tauri_plugin_yourapp::YourAppExt;

    let app = GLOBAL_APP_HANDLE
        .get()
        .expect("Failed to get GLOBAL_APP_HANDLE");
    let res = app
        .yourapp()
        .check_permissions()
        .expect("Failed to request read audio permission");
    if res.audio != PermissionState::Granted {
        return app
            .yourapp()
            .request_permissions(Some(vec![PermissionType::Audio]))
            .unwrap()
            .audio
            == PermissionState::Granted;
    }
    true
}

Note : I'm not sure how to call it directly via index.ts inside the guest-js since Vite can't include js outside the project. So I just call it in my Rust project instead. Correct me if I'm wrong.