Asociaciones de archivos en móviles

Tauri admite asociaciones de archivos en Android e iOS, lo que permite que tu app se registre como un manejador para tipos de archivos específicos. Cuando un usuario abre un archivo que coincide con tus asociaciones declaradas, el sistema operativo inicia tu aplicación y le entrega la URL del archivo.

En Android, las asociaciones de archivos se implementan utilizando intent filters que el sistema de compilación de Tauri genera automáticamente a partir de tu configuración.

En iOS, las asociaciones de archivos usan CFBundleDocumentTypes y opcionalmente UTExportedTypeDeclarations para tipos de archivos personalizados.

Configuración

Las asociaciones de archivos se declaran en tauri.conf.json dentro de bundle.fileAssociations. La CLI de Tauri utiliza esta configuración para generar los metadatos específicos de la plataforma correspondientes (intent filters de Android en AndroidManifest.xml, tipos de documento de iOS en Info.plist).

Cada entrada en el array representa un tipo de archivo que tu app puede manejar:

src-tauri/tauri.conf.json

{
  "bundle": {
    "fileAssociations": [
      {
        "ext": ["png"],
        "mimeType": "image/png"
      },
      {
        "ext": ["jpg", "jpeg"],
        "mimeType": "image/jpeg"
      }
    ]
  }
}

Opciones de configuración

• ext — lista de extensiones de archivos para asociar (sin el punto inicial).
• mimeType — el tipo MIME para el archivo (p. ej. image/png). Requerido en Android para la coincidencia de intent filters. Tauri infiere los tipos MIME comunes a partir de las extensiones cuando no se especifican.
• role — el rol de la aplicación con respecto al tipo de archivo. Se asigna a CFBundleTypeRole en plataformas de Apple. Valores: Editor (predeterminado), Viewer, Shell, QLGenerator, None.
• rank — el orden de prioridad entre las aplicaciones que manejan este tipo de archivo. Se asigna a LSHandlerRank en plataformas de Apple. Valores: Default (predeterminado), Owner, Alternate, None.
• name — nombre visible para el tipo de archivo. Por defecto toma la primera extensión.
• exportedType — define un tipo de archivo personalizado perteneciente a tu aplicación. Requerido en plataformas de Apple al asociar con extensiones de archivo no estándar.
• androidIntentActionFilters — qué acciones de intent de Android registrar. Valores: Send, SendMultiple, View. Las tres se utilizan por defecto.

Tipos de archivo personalizados

Para extensiones de archivo no estándar, debes definir un exportedType para que las plataformas de Apple puedan identificar el tipo de archivo. El identifier debe ser una cadena DNS inversa única para tu app, y conformsTo lista los tipos primarios:

src-tauri/tauri.conf.json

{
  "bundle": {
    "fileAssociations": [
      {
        "ext": ["mydata"],
        "mimeType": "application/octet-stream",
        "exportedType": {
          "identifier": "com.example.myapp.mydata",
          "conformsTo": ["public.data"]
        }
      }
    ]
  }
}

Los valores comunes de conformsTo incluyen public.data, public.image, public.json y public.plain-text.

Manejo de archivos abiertos

Cuando se abre un archivo con tu aplicación, Tauri emite un evento RunEvent::Opened que contiene las URLs de los archivos. Este evento está disponible en macOS, iOS y Android.

Debes manejar dos casos:

1. La app ya se está ejecutando — el evento se entrega en tiempo de ejecución.
2. La app es iniciada al abrir el archivo — el evento se dispara durante el inicio, por lo que debes almacenar las URLs y hacerlas disponibles para tu frontend.

Rust

Almacena las URLs entrantes en el estado gestionado, exponlas con un comando que el frontend pueda llamar al iniciar, y emite un evento de Tauri cada vez que se dispare RunEvent::Opened para que el frontend pueda reaccionar mientras la app ya se esté ejecutando:

src-tauri/src/lib.rs

use std::sync::Mutex;
use tauri::Manager;

struct OpenedUrls(Mutex<Vec<tauri::Url>>);

#[tauri::command]
fn opened_urls(app: tauri::AppHandle) -> Vec<tauri::Url> {
    app.state::<OpenedUrls>().0.lock().unwrap().clone()
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .manage(OpenedUrls(Mutex::new(vec![])))
        .invoke_handler(tauri::generate_handler![opened_urls])
        .build(tauri::generate_context!())
        .expect("error while running tauri application")
        .run(|app, event| {
            #[cfg(any(target_os = "macos", target_os = "ios", target_os = "android"))]
            if let tauri::RunEvent::Opened { urls } = event {
                use tauri::Emitter;
                app.state::<OpenedUrls>()
                    .0
                    .lock()
                    .unwrap()
                    .extend(urls.clone());
                app.emit("opened", urls).unwrap();
            }
        });
}

JavaScript

El frontend a continuación está conectado a ese código de Rust en dos lugares:

• invoke('opened_urls') llama al comando opened_urls, de modo que la webview pueda leer las URLs que se almacenaron antes de que la interfaz de usuario terminara de cargarse (inicio en frío desde la apertura de un archivo).
• listen('opened', …) se suscribe al mismo nombre de evento pasado a app.emit("opened", urls) en Rust, de modo que los eventos de apertura de archivos que se activan mientras la app ya está ejecutándose se entreguen de inmediato.

import { listen } from '@tauri-apps/api/event';
import { invoke } from '@tauri-apps/api/core';

// Cold start: URLs may already be in Rust state before the frontend loads
const initialUrls = await invoke('opened_urls');
if (initialUrls.length > 0) {
  handleFiles(initialUrls);
}

// Warm: Rust emits the "opened" event when RunEvent::Opened fires
await listen('opened', (event) => {
  handleFiles(event.payload);
});