fix(mobile): use android-fs for android pickers and clean up ios copies

This commit is contained in:
Erwan Leboucher authored and 7w1 committed 2026-08-08 21:18:28 -05:00
1 parent 5d631e0439
commit 8856fc69ad
7 files changed
+367 -77

No files matched your search

+1 -1
View File
@@ -125,7 +125,6 @@ tauri-plugin-notifications = { git = "https://github.com/SableClient/tauri-plugi
tauri-plugin-edge-to-edge = { git = "https://github.com/SableClient/tauri-plugin-edge-to-edge.git", rev = "33c6116c27be28c06df5a9d02231ecc5fdeb93c5" }
tauri-plugin-sharekit = { git = "https://github.com/Choochmeque/tauri-plugin-sharekit", rev = "9f2b4c5d8a4f0ab910d900ba234ed8bae0ab854b" }
tauri-plugin-app-icon = { git = "https://github.com/SableClient/tauri-plugin-app-icon", rev = "9248a3370dca5c9b1640b20806002fe59d25fa57" }
tauri-plugin-fs = "2"
[target.'cfg(target_os = "ios")'.dependencies]
objc2 = "0.6"
@@ -148,6 +147,7 @@ objc2-photos = { version = "0.3.2", default-features = false, features = [
"dispatch2",
] }
block2 = "0.6"
tauri-plugin-fs = "2"
objc2-avf-audio = { version = "0.3", default-features = false, features = [
"AVAudioSession",
"AVAudioSessionTypes",
+3 -2
View File
@@ -4,8 +4,9 @@
"platforms": ["android"],
"windows": ["main"],
"permissions": [
"dialog:allow-open",
"fs:allow-read-file",
"android-fs:allow-show-open-file-picker",
"android-fs:allow-get-metadata",
"android-fs:allow-read-file",
"android-fs:allow-check-public-files-permission",
"android-fs:allow-create-new-public-file",
"android-fs:allow-create-new-public-image-file",
+8 -1
View File
@@ -7,6 +7,13 @@
"dialog:allow-save",
"dialog:allow-open",
"fs:allow-write-file",
"fs:allow-read-file"
{
"identifier": "fs:allow-read-file",
"allow": [{ "path": "$TEMP/**/*" }, { "path": "$APPCACHE/**/*" }]
},
{
"identifier": "fs:allow-remove",
"allow": [{ "path": "$TEMP/**/*" }, { "path": "$APPCACHE/**/*" }]
}
]
}
-5
View File
@@ -359,11 +359,6 @@ pub fn run() {
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_fs::init());
#[cfg(target_os = "android")]
let builder = builder
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_fs::init());
#[cfg(mobile)]
let builder = builder
.plugin(tauri_plugin_app_icon::init())
+99 -17
View File
@@ -158,6 +158,8 @@ import {
dropzoneIcon,
File as FileIcon,
Gif,
ListBullets,
MapPinPlusIcon,
menuIcon,
Microphone,
PaperPlaneTilt,
@@ -327,6 +329,7 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
const clientConfig = useClientConfig();
const useAuthentication = useMediaAuthentication();
const [enterForNewline] = useSetting(settingsAtom, 'enterForNewline');
const [editorOldAddFile] = useSetting(settingsAtom, 'editorOldAddFile');
const [editorGifButton] = useSetting(settingsAtom, 'editorGifButton');
const [editorEmojiButton] = useSetting(settingsAtom, 'editorEmojiButton');
const [editorStickerButton] = useSetting(settingsAtom, 'editorStickerButton');
@@ -498,7 +501,11 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
}, []);
const handleFiles = useCallback(
async (files: File[], audioMeta?: { waveform: number[]; audioDuration: number }) => {
async (
files: File[],
audioMeta?: { waveform: number[]; audioDuration: number },
options?: { alreadyInMemory?: boolean }
) => {
const epoch = draftEpochRef.current;
fileIngestionCountRef.current += 1;
setIngestingFiles(true);
@@ -508,18 +515,19 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
if (epoch !== draftEpochRef.current || !mountedRef.current) return;
// Eager-read to avoid Android content URI expiry after SAF picker
const blobbedFiles = isMobileOrTablet()
? await Promise.all(
safeFiles.map(async (f) => {
try {
const buf = await f.arrayBuffer();
return new File([buf], f.name, { type: f.type, lastModified: f.lastModified });
} catch {
return f;
}
})
)
: safeFiles;
const blobbedFiles =
isMobileOrTablet() && !options?.alreadyInMemory
? await Promise.all(
safeFiles.map(async (f) => {
try {
const buf = await f.arrayBuffer();
return new File([buf], f.name, { type: f.type, lastModified: f.lastModified });
} catch {
return f;
}
})
)
: safeFiles;
if (epoch !== draftEpochRef.current || !mountedRef.current) return;
blobbedFiles.forEach((file) => removedUploadFilesRef.current.delete(file));
@@ -601,10 +609,10 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
}
try {
const files = await pickNativeFile(pickerMode, (path, error) => {
log.warn('Failed to read native attachment file:', path, error);
const files = await pickNativeFile(pickerMode, (source, error) => {
log.warn('Native attachment file error:', source, error);
});
if (files.length > 0) await handleFiles(files);
if (files.length > 0) await handleFiles(files, undefined, { alreadyInMemory: true });
} catch (error) {
log.error('Failed to open native attachment picker', { roomId }, error);
}
@@ -686,6 +694,7 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
},
[setRoomEditingScheduledDelayId, threadRootId]
);
const [AddMenuAnchor, setAddMenuAnchor] = useState<RectCords>();
const [showAttachmentSheet, setShowAttachmentSheet] = useState(false);
const attachmentSkipReturnFocusRef = useRef(false);
const [showPollPicker, setShowPollPicker] = useState(false);
@@ -2219,7 +2228,7 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
}
before={
<>
{isMobileOrTablet() && (
{isMobileOrTablet() ? (
<>
<IconButton
onClick={() => {
@@ -2264,6 +2273,79 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
</MobileSwipeDownModal>
)}
</>
) : (
<>
<PopOut
anchor={AddMenuAnchor}
position="Top"
align="Start"
offset={5}
content={
<FocusTrap
focusTrapOptions={{
initialFocus: false,
onDeactivate: () => setAddMenuAnchor(undefined),
clickOutsideDeactivates: true,
escapeDeactivates: stopPropagation,
}}
>
<Menu>
<Box direction="Column" gap="100" style={{ padding: config.space.S100 }}>
<MenuItem
size="300"
radii="300"
onClick={() => {
setAddMenuAnchor(undefined);
setShowPollPicker(true);
}}
before={menuIcon(ListBullets)}
>
<Text size="B300">Create Poll</Text>
</MenuItem>
<MenuItem
size="300"
radii="300"
onClick={() => {
setAddMenuAnchor(undefined);
setShowLocationPicker(true);
}}
before={menuIcon(MapPinPlusIcon)}
>
<Text size="B300">Add Location</Text>
</MenuItem>
<MenuItem
size="300"
radii="300"
onClick={() => {
pickFile('*');
setAddMenuAnchor(undefined);
}}
before={menuIcon(PlusCircle)}
>
<Text size="B300">Add File</Text>
</MenuItem>
</Box>
</Menu>
</FocusTrap>
}
/>
<IconButton
onClick={(evt) =>
editorOldAddFile
? pickFile('*')
: setAddMenuAnchor(evt.currentTarget.getBoundingClientRect())
}
onPointerDown={suppressEditorRefocus}
variant="SurfaceVariant"
size="300"
radii="300"
style={{ backgroundColor: 'transparent' }}
title={editorOldAddFile ? 'Upload File' : 'Add'}
aria-label={editorOldAddFile ? 'Upload and attach a File' : 'Add new Item'}
>
{composerIcon(PlusCircle)}
</IconButton>
</>
)}
{pmpPickerEnable && (
<PersistentPersonaPicker
+186 -41
View File
@@ -1,8 +1,13 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { open } from '@tauri-apps/plugin-dialog';
import { readFile } from '@tauri-apps/plugin-fs';
import { readFile, remove } from '@tauri-apps/plugin-fs';
import { pickNativeFile } from './nativeFilePicker';
type AndroidUri = { uri: string; documentTopTreeUri: string | null };
type AndroidMetadata =
| { type: 'File'; name: string; lastModified: Date; byteLength: number; mimeType: string }
| { type: 'Dir'; name: string; lastModified: Date };
const mocks = vi.hoisted(() => ({
open: vi.fn<
(options: {
@@ -11,72 +16,212 @@ const mocks = vi.hoisted(() => ({
}) => Promise<string | string[] | null>
>(),
readFile: vi.fn<(path: string) => Promise<Uint8Array>>(),
remove: vi.fn<(path: string) => Promise<void>>(),
androidFs: {
showOpenFilePicker:
vi.fn<
(options: {
pickerType: 'Gallery' | 'FilePicker';
mimeTypes: string[];
multiple: boolean;
}) => Promise<AndroidUri[]>
>(),
getMetadata: vi.fn<(uri: AndroidUri) => Promise<AndroidMetadata>>(),
readFile: vi.fn<(uri: AndroidUri) => Promise<Uint8Array>>(),
},
isAndroidTauri: vi.fn<() => boolean>(),
}));
vi.mock('@tauri-apps/plugin-dialog', () => ({ open: mocks.open }));
vi.mock('@tauri-apps/plugin-fs', () => ({ readFile: mocks.readFile }));
vi.mock('@tauri-apps/plugin-fs', () => ({ readFile: mocks.readFile, remove: mocks.remove }));
vi.mock('tauri-plugin-android-fs-api', () => ({ AndroidFs: mocks.androidFs }));
vi.mock('$utils/platform', () => ({ isAndroidTauri: mocks.isAndroidTauri }));
const androidUri = (uri: string): AndroidUri => ({ uri, documentTopTreeUri: null });
describe('pickNativeFile', () => {
beforeEach(() => {
mocks.isAndroidTauri.mockReturnValue(false);
mocks.open.mockResolvedValue(null);
mocks.readFile.mockResolvedValue(new Uint8Array([1, 2, 3]));
mocks.remove.mockResolvedValue(undefined);
mocks.androidFs.showOpenFilePicker.mockResolvedValue([]);
mocks.androidFs.readFile.mockResolvedValue(new Uint8Array([1, 2, 3]));
});
afterEach(() => {
vi.clearAllMocks();
});
it('opens the native media picker and converts selected paths to Files', async () => {
mocks.open.mockResolvedValue(['/photos/My%20photo.JPG', '/videos/clip.mp4']);
describe('on iOS', () => {
it('opens the native media picker and converts selected files', async () => {
mocks.open.mockResolvedValue([
'file:///var/mobile/Library/Caches/My%20photo.JPG',
'file:///var/mobile/Library/Caches/clip.mp4',
]);
const files = await pickNativeFile('media');
const files = await pickNativeFile('media');
expect(open).toHaveBeenCalledWith({ pickerMode: 'media', multiple: true });
expect(readFile).toHaveBeenCalledWith('/photos/My%20photo.JPG');
expect(readFile).toHaveBeenCalledWith('/videos/clip.mp4');
expect(files.map(({ name, type }) => ({ name, type }))).toEqual([
{ name: 'My photo.JPG', type: 'image/jpeg' },
{ name: 'clip.mp4', type: 'video/mp4' },
]);
expect(open).toHaveBeenCalledWith({ pickerMode: 'media', multiple: true });
expect(files.map(({ name, type }) => ({ name, type }))).toEqual([
{ name: 'My photo.JPG', type: 'image/jpeg' },
{ name: 'clip.mp4', type: 'video/mp4' },
]);
});
it('deletes the sandbox copies the picker handed over', async () => {
mocks.open.mockResolvedValue(['/Caches/a.png', '/Caches/b.pdf']);
await pickNativeFile('document');
expect(readFile).toHaveBeenCalledWith('/Caches/a.png');
expect(remove).toHaveBeenCalledWith('/Caches/a.png');
expect(remove).toHaveBeenCalledWith('/Caches/b.pdf');
});
it('reports read failures, keeps readable files and still deletes the copies', async () => {
const failure = new Error('permission denied');
mocks.open.mockResolvedValue(['/Caches/readable.png', '/Caches/unreadable.jpg']);
mocks.readFile.mockResolvedValueOnce(new Uint8Array([1])).mockRejectedValueOnce(failure);
const onFileFailure = vi.fn<(source: string, error: unknown) => void>();
const files = await pickNativeFile('media', onFileFailure);
expect(files).toHaveLength(1);
expect(files[0]?.name).toBe('readable.png');
expect(onFileFailure).toHaveBeenCalledWith('/Caches/unreadable.jpg', failure);
expect(remove).toHaveBeenCalledWith('/Caches/unreadable.jpg');
});
it('reports a failed cleanup without dropping the file', async () => {
const failure = new Error('cleanup failed');
mocks.open.mockResolvedValue(['/Caches/photo.png']);
mocks.remove.mockRejectedValue(failure);
const onFileFailure = vi.fn<(source: string, error: unknown) => void>();
const files = await pickNativeFile('media', onFileFailure);
expect(files).toHaveLength(1);
expect(onFileFailure).toHaveBeenCalledWith('/Caches/photo.png', failure);
});
it('does not read files after picker cancellation', async () => {
const files = await pickNativeFile('media');
expect(files).toEqual([]);
expect(readFile).not.toHaveBeenCalled();
expect(remove).not.toHaveBeenCalled();
});
it('propagates picker errors without attempting another picker', async () => {
const error = new Error('picker failed');
mocks.open.mockRejectedValue(error);
await expect(pickNativeFile('media')).rejects.toBe(error);
expect(readFile).not.toHaveBeenCalled();
});
it('opens the native document picker for documents', async () => {
mocks.open.mockResolvedValue('/documents/report.pdf');
const files = await pickNativeFile('document');
expect(open).toHaveBeenCalledWith({ pickerMode: 'document', multiple: true });
expect(files.map(({ name, type }) => ({ name, type }))).toEqual([
{ name: 'report.pdf', type: 'application/pdf' },
]);
});
});
it('returns readable files when an individual read fails', async () => {
const failure = new Error('permission denied');
mocks.open.mockResolvedValue(['/photos/readable.png', '/photos/unreadable.jpg']);
mocks.readFile.mockResolvedValueOnce(new Uint8Array([1])).mockRejectedValueOnce(failure);
const onReadFailure = vi.fn<(path: string, error: unknown) => void>();
describe('on Android', () => {
beforeEach(() => {
mocks.isAndroidTauri.mockReturnValue(true);
});
const files = await pickNativeFile('media', onReadFailure);
it('picks media through the gallery and takes name and mime from the provider', async () => {
const uri = androidUri('content://media/external/images/media/1000000034');
mocks.androidFs.showOpenFilePicker.mockResolvedValue([uri]);
mocks.androidFs.getMetadata.mockResolvedValue({
type: 'File',
name: '1000000034.png',
lastModified: new Date(1700000000000),
byteLength: 3,
mimeType: 'image/png',
});
expect(files).toHaveLength(1);
expect(files[0]?.name).toBe('readable.png');
expect(onReadFailure).toHaveBeenCalledWith('/photos/unreadable.jpg', failure);
});
const files = await pickNativeFile('media');
it('does not read files after picker cancellation', async () => {
const files = await pickNativeFile('media');
expect(mocks.androidFs.showOpenFilePicker).toHaveBeenCalledWith({
pickerType: 'Gallery',
mimeTypes: ['image/*', 'video/*'],
multiple: true,
});
expect(mocks.androidFs.readFile).toHaveBeenCalledWith(uri);
expect(open).not.toHaveBeenCalled();
expect(files.map(({ name, type, lastModified }) => ({ name, type, lastModified }))).toEqual([
{ name: '1000000034.png', type: 'image/png', lastModified: 1700000000000 },
]);
});
expect(files).toEqual([]);
expect(readFile).not.toHaveBeenCalled();
});
it('picks documents through the file picker', async () => {
mocks.androidFs.showOpenFilePicker.mockResolvedValue([androidUri('content://docs/1')]);
mocks.androidFs.getMetadata.mockResolvedValue({
type: 'File',
name: 'report.pdf',
lastModified: new Date(1700000000000),
byteLength: 3,
mimeType: 'application/pdf',
});
it('propagates picker errors without attempting another picker', async () => {
const error = new Error('picker failed');
mocks.open.mockRejectedValue(error);
const files = await pickNativeFile('document');
await expect(pickNativeFile('media')).rejects.toBe(error);
expect(readFile).not.toHaveBeenCalled();
});
expect(mocks.androidFs.showOpenFilePicker).toHaveBeenCalledWith({
pickerType: 'FilePicker',
mimeTypes: [],
multiple: true,
});
expect(files.map(({ name, type }) => ({ name, type }))).toEqual([
{ name: 'report.pdf', type: 'application/pdf' },
]);
});
it('opens the native document picker and converts selected paths to Files', async () => {
mocks.open.mockResolvedValue('/documents/report.pdf');
it('falls back to the extension when the provider reports a generic mime type', async () => {
mocks.androidFs.showOpenFilePicker.mockResolvedValue([androidUri('content://docs/2')]);
mocks.androidFs.getMetadata.mockResolvedValue({
type: 'File',
name: 'sticker.tgs',
lastModified: new Date(1700000000000),
byteLength: 3,
mimeType: 'application/octet-stream',
});
const files = await pickNativeFile('document');
const files = await pickNativeFile('document');
expect(open).toHaveBeenCalledWith({ pickerMode: 'document', multiple: true });
expect(readFile).toHaveBeenCalledWith('/documents/report.pdf');
expect(files.map(({ name, type }) => ({ name, type }))).toEqual([
{ name: 'report.pdf', type: 'application/pdf' },
]);
expect(files[0]?.type).toBe('application/x-tgsticker');
});
it('reports failures per file and skips directories', async () => {
const failure = new Error('no read permission');
const dir = androidUri('content://docs/dir');
const broken = androidUri('content://docs/broken');
mocks.androidFs.showOpenFilePicker.mockResolvedValue([dir, broken]);
mocks.androidFs.getMetadata
.mockResolvedValueOnce({ type: 'Dir', name: 'folder', lastModified: new Date(0) })
.mockRejectedValueOnce(failure);
const onFileFailure = vi.fn<(source: string, error: unknown) => void>();
const files = await pickNativeFile('document', onFileFailure);
expect(files).toEqual([]);
expect(onFileFailure).toHaveBeenCalledWith('content://docs/broken', failure);
expect(mocks.androidFs.readFile).not.toHaveBeenCalled();
});
it('returns no files when the picker is cancelled', async () => {
const files = await pickNativeFile('media');
expect(files).toEqual([]);
expect(mocks.androidFs.getMetadata).not.toHaveBeenCalled();
});
});
});
+70 -10
View File
@@ -1,32 +1,42 @@
import { FALLBACK_MIMETYPE, TGS_MIMETYPE } from '$utils/mimeTypes';
import { isAndroidTauri } from '$utils/platform';
const MIME_TYPES_BY_EXTENSION: Record<string, string> = {
aac: 'audio/aac',
apng: 'image/apng',
avif: 'image/avif',
bmp: 'image/bmp',
flac: 'audio/flac',
gif: 'image/gif',
heic: 'image/heic',
heif: 'image/heif',
json: 'application/json',
jpeg: 'image/jpeg',
jpg: 'image/jpeg',
m4a: 'audio/mp4',
md: 'text/markdown',
mov: 'video/quicktime',
mp3: 'audio/mpeg',
mp4: 'video/mp4',
m4v: 'video/mp4',
ogg: 'video/ogg',
oga: 'audio/ogg',
ogg: 'audio/ogg',
ogv: 'video/ogg',
opus: 'audio/opus',
pdf: 'application/pdf',
png: 'image/png',
svg: 'image/svg+xml',
tgs: TGS_MIMETYPE,
txt: 'text/plain',
wav: 'audio/wav',
webm: 'video/webm',
webp: 'image/webp',
};
const MEDIA_MIME_TYPES = ['image/*', 'video/*'];
export type NativePickerMode = 'media' | 'document';
export type NativeFileReadFailureHandler = (path: string, error: unknown) => void;
export type NativeFileFailureHandler = (source: string, error: unknown) => void;
const normalizeSelectedPaths = (selected: string | string[] | null | undefined): string[] =>
(typeof selected === 'string' ? [selected] : (selected ?? [])).filter((path) => path.length > 0);
@@ -42,33 +52,83 @@ const getFileName = (path: string, index: number): string => {
}
};
const getMimeType = (fileName: string): string => {
const getMimeTypeFromName = (fileName: string): string => {
const extension = fileName.split('.').pop()?.toLowerCase();
return extension ? (MIME_TYPES_BY_EXTENSION[extension] ?? FALLBACK_MIMETYPE) : FALLBACK_MIMETYPE;
};
export const pickNativeFile = async (
const resolveMimeType = (fileName: string, reportedMimeType?: string): string =>
reportedMimeType && reportedMimeType !== FALLBACK_MIMETYPE
? reportedMimeType
: getMimeTypeFromName(fileName);
const isFile = (file: File | undefined): file is File => file !== undefined;
const pickAndroidFiles = async (
pickerMode: NativePickerMode,
onReadFailure?: NativeFileReadFailureHandler
onFileFailure?: NativeFileFailureHandler
): Promise<File[]> => {
const { AndroidFs } = await import('tauri-plugin-android-fs-api');
const uris = await AndroidFs.showOpenFilePicker({
pickerType: pickerMode === 'media' ? 'Gallery' : 'FilePicker',
mimeTypes: pickerMode === 'media' ? MEDIA_MIME_TYPES : [],
multiple: true,
});
const files = await Promise.all(
uris.map(async (uri, index): Promise<File | undefined> => {
try {
const metadata = await AndroidFs.getMetadata(uri);
if (metadata.type !== 'File') return undefined;
const name = metadata.name || `attachment-${index + 1}`;
const contents = await AndroidFs.readFile(uri);
return new File([contents], name, {
type: resolveMimeType(name, metadata.mimeType),
lastModified: metadata.lastModified.getTime(),
});
} catch (error) {
onFileFailure?.(uri.uri, error);
return undefined;
}
})
);
return files.filter(isFile);
};
const pickIosFiles = async (
pickerMode: NativePickerMode,
onFileFailure?: NativeFileFailureHandler
): Promise<File[]> => {
const { open } = await import('@tauri-apps/plugin-dialog');
const selected = await open({ pickerMode, multiple: true });
const paths = normalizeSelectedPaths(selected);
if (paths.length === 0) return [];
const { readFile } = await import('@tauri-apps/plugin-fs');
const { readFile, remove } = await import('@tauri-apps/plugin-fs');
const files = await Promise.all(
paths.map(async (path, index): Promise<File | undefined> => {
const name = getFileName(path, index);
try {
const name = getFileName(path, index);
const contents = await readFile(path);
return new File([contents], name, { type: getMimeType(name) });
return new File([contents], name, { type: getMimeTypeFromName(name) });
} catch (error) {
onReadFailure?.(path, error);
onFileFailure?.(path, error);
return undefined;
} finally {
await remove(path).catch((error: unknown) => onFileFailure?.(path, error));
}
})
);
return files.filter((file): file is File => file !== undefined);
return files.filter(isFile);
};
export const pickNativeFile = async (
pickerMode: NativePickerMode,
onFileFailure?: NativeFileFailureHandler
): Promise<File[]> =>
isAndroidTauri()
? pickAndroidFiles(pickerMode, onFileFailure)
: pickIosFiles(pickerMode, onFileFailure);