tauri-plugin-macos-permissions

To use this plugin, you must install both the Rust backend dependency and the JavaScript guest bindings.

1. Add the Rust plugin to your Tauri project:

   cargo add tauri-plugin-macos-permissions

2. Install the JavaScript API package using your preferred package manager:

   pnpm add tauri-plugin-macos-permissions-api

Note: This plugin is designed specifically for Tauri v2.

# Install Rust dependency
cargo add tauri-plugin-macos-permissions

# Install JS API
pnpm add tauri-plugin-macos-permissions-api

If your application requires access to the microphone or camera, you must provide usage descriptions in your src-tauri/Info.plist file. Failure to do so will result in the permission requests failing or the app being rejected by macOS.

Add the following keys to your Info.plist:

• NSMicrophoneUsageDescription: A string explaining why your app needs microphone access.
• NSCameraUsageDescription: A string explaining why your app needs camera access.

<key>NSMicrophoneUsageDescription</key>
<string>Describe why your app needs to use microphone permission</string>
<key>NSCameraUsageDescription</key>
<string>Describe why your app needs to use camera permissions</string>

To develop with this template effectively, it is recommended to use VS Code with the following extensions installed:

• Tauri extension: For Tauri-specific tooling.
• rust-analyzer: For Rust language support and intelligence.

After installing the dependencies, you must register the plugin in your Rust entry point and grant permissions in your capabilities configuration.

1. Register the plugin in Rust

In your src-tauri/src/lib.rs, initialize the plugin within the tauri::Builder:

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_macos_permissions::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

2. Grant permissions in Capabilities

Update your src-tauri/capabilities/default.json to include the macos-permissions:default permission:

{
    "permissions": [
        "macos-permissions:default"
    ]
}

// src-tauri/src/lib.rs
.plugin(tauri_plugin_macos_permissions::init())

To use the macOS permissions functionality in your Tauri application, you must register the plugin in your main.rs or lib.rs using the init() function. This registers the available permission commands (Accessibility, Full Disk Access, Screen Recording, Microphone, Camera, and Input Monitoring) with the Tauri runtime.

use tauri_plugin_macos_permissions::init;

fn main() {
    tauri::Builder::default()
        .plugin(init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

To explore the plugin in a working environment, you can clone the repository and run the provided example application:

1. Clone the repo: git clone https://github.com/ayangweb/tauri-plugin-macos-permissions.git
2. Install dependencies and build the plugin: pnpm install && pnpm build
3. Navigate to the example app and run it: cd examples/tauri-app && pnpm install && pnpm tauri dev

By default, the plugin includes a set of permissions that allow checking and requesting various macOS system permissions. If you are using the default configuration, the following permission types are available for use in your Tauri application:

- `allow-check-accessibility-permission`
- `allow-request-accessibility-permission`
- `allow-check-full-disk-access-permission`
- `allow-request-full-disk-access-permission`
- `allow-check-screen-recording-permission`
- `allow-request-screen-recording-permission`
- `allow-check-microphone-permission`
- `allow-request-microphone-permission`
- `allow-check-camera-permission`
- `allow-request-camera-permission`
- `allow-check-input-monitoring-permission`
- `allow-request-input-monitoring-permission`

Use check_screen_recording_permission to determine if the application currently has permission to record the screen.

On macOS, this checks the system's screen capture access status. On non-macOS platforms, it defaults to returning true.

```rust
use tauri_plugin_macos_permissions::check_screen_recording_permission;

let authorized = check_screen_recording_permission().await;
println!(

Use check_camera_permission to determine if the application currently has authorization to access the camera.

On macOS, it checks the AVCaptureDevice authorization status for the vide media type. On other platforms, it defaults to returning true.

use tauri_plugin_macos_permissions::check_camera_permission;

let authorized = check_camera_permission().await;
println!("Authorized: {}", authorized); // true or false

Use request_microphone_permission to trigger the system permission prompt for microphone access.

On macOS, this invokes the requestAccessForMediaType method on AVCaptureDevice. This is an asynchronous operation that requests the user's consent via the standard macOS system dialog.

Returns Ok(()) if the request was initiated, or an Err(String) if an error occurred.

use tauri_plugin_macos_permissions::request_microphone_permission;

request_microphone_permission().await.expect("Failed to request permission");