@simplysm/capacitor-plugin-file-system 12.15.69

package/android/build.gradle

@@ -0,0 +1,9 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "kr.co.simplysm.capacitor.filesystem"
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
+
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+                   android:maxSdkVersion="32"/>
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+                   android:maxSdkVersion="29"/>
+  <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
+                   tools:ignore="ScopedStorage"/>
+
+  <application>
+    <provider
+      android:name=".FileSystemProvider"
+      android:authorities="${applicationId}.filesystem.provider"
+      android:exported="false"
+      android:grantUriPermissions="true">
+      <meta-data
+        android:name="android.support.FILE_PROVIDER_PATHS"
+        android:resource="@xml/file_provider_paths"/>
+    </provider>
+  </application>
+</manifest>

package/android/src/main/java/kr/co/simplysm/capacitor/filesystem/FileSystemPlugin.java

@@ -0,0 +1,289 @@
+package kr.co.simplysm.capacitor.filesystem;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.Settings;
+import android.util.Base64;
+import android.util.Log;
+
+import androidx.core.content.ContextCompat;
+import androidx.core.content.FileProvider;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+
+@CapacitorPlugin(name = "FileSystem")
+public class FileSystemPlugin extends Plugin {
+
+    private static final String TAG = "FileSystemPlugin";
+
+    @PluginMethod
+    public void checkPermission(PluginCall call) {
+        boolean granted;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            granted = Environment.isExternalStorageManager();
+        } else {
+            Context ctx = getContext();
+            granted = ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
+                   && ContextCompat.checkSelfPermission(ctx, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+        }
+        JSObject ret = new JSObject();
+        ret.put("granted", granted);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void requestPermission(PluginCall call) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            if (!Environment.isExternalStorageManager()) {
+                Intent intent = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
+                intent.setData(Uri.parse("package:" + getContext().getPackageName()));
+                getActivity().startActivity(intent);
+            }
+        }
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void readdir(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        File dir = new File(path);
+        if (!dir.exists() || !dir.isDirectory()) {
+            call.reject("Directory does not exist");
+            return;
+        }
+
+        File[] files = dir.listFiles();
+        if (files == null) {
+            call.reject("Cannot read directory");
+            return;
+        }
+
+        JSArray result = new JSArray();
+        for (File f : files) {
+            JSObject info = new JSObject();
+            info.put("name", f.getName());
+            info.put("isDirectory", f.isDirectory());
+            result.put(info);
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("files", result);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getStoragePath(PluginCall call) {
+        String type = call.getString("type");
+        if (type == null) {
+            call.reject("type is required");
+            return;
+        }
+
+        Context ctx = getContext();
+        File path;
+
+        switch (type) {
+            case "external":
+                path = Environment.getExternalStorageDirectory();
+                break;
+            case "externalFiles":
+                path = ctx.getExternalFilesDir(null);
+                break;
+            case "externalCache":
+                path = ctx.getExternalCacheDir();
+                break;
+            case "externalMedia":
+                File[] dirs = ctx.getExternalMediaDirs();
+                path = (dirs.length > 0) ? dirs[0] : null;
+                break;
+            case "appData":
+                path = new File(ctx.getApplicationInfo().dataDir);
+                break;
+            case "appFiles":
+                path = ctx.getFilesDir();
+                break;
+            case "appCache":
+                path = ctx.getCacheDir();
+                break;
+            default:
+                call.reject("Unknown type: " + type);
+                return;
+        }
+
+        if (path == null) {
+            call.reject("Path not available");
+            return;
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("path", path.getAbsolutePath());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getFileUri(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        try {
+            String authority = getContext().getPackageName() + ".filesystem.provider";
+            Uri uri = FileProvider.getUriForFile(getContext(), authority, new File(path));
+            JSObject ret = new JSObject();
+            ret.put("uri", uri.toString());
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "getFileUri failed", e);
+            call.reject("getFileUri failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void writeFile(PluginCall call) {
+        String path = call.getString("path");
+        String data = call.getString("data");
+        String encoding = call.getString("encoding", "utf8");
+
+        if (path == null || data == null) {
+            call.reject("path and data are required");
+            return;
+        }
+
+        try {
+            File file = new File(path);
+            File parent = file.getParentFile();
+            if (parent != null && !parent.exists()) {
+                parent.mkdirs();
+            }
+
+            byte[] bytes = "base64".equals(encoding)
+                ? Base64.decode(data, Base64.DEFAULT)
+                : data.getBytes(StandardCharsets.UTF_8);
+
+            try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file))) {
+                bos.write(bytes);
+            }
+
+            call.resolve();
+        } catch (Exception e) {
+            Log.e(TAG, "writeFile failed", e);
+            call.reject("Write failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void readFile(PluginCall call) {
+        String path = call.getString("path");
+        String encoding = call.getString("encoding", "utf8");
+
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        File file = new File(path);
+        if (!file.exists()) {
+            call.reject("File not found: " + path);
+            return;
+        }
+
+        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+
+            byte[] buf = new byte[8192];
+            int len;
+            while ((len = bis.read(buf)) != -1) {
+                baos.write(buf, 0, len);
+            }
+
+            String result = "base64".equals(encoding)
+                ? Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP)
+                : baos.toString("UTF-8");
+
+            JSObject ret = new JSObject();
+            ret.put("data", result);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "readFile failed", e);
+            call.reject("Read failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void remove(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        if (deleteRecursively(new File(path))) {
+            call.resolve();
+        } else {
+            call.reject("Delete failed");
+        }
+    }
+
+    @PluginMethod
+    public void mkdir(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        File dir = new File(path);
+        if (dir.exists() || dir.mkdirs()) {
+            call.resolve();
+        } else {
+            call.reject("Failed to create directory");
+        }
+    }
+
+    @PluginMethod
+    public void exists(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("exists", new File(path).exists());
+        call.resolve(ret);
+    }
+
+    private boolean deleteRecursively(File file) {
+        if (file.isDirectory()) {
+            File[] children = file.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    if (!deleteRecursively(child)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return file.delete();
+    }
+}

package/android/src/main/java/kr/co/simplysm/capacitor/filesystem/FileSystemProvider.java

@@ -0,0 +1,6 @@
+package kr.co.simplysm.capacitor.filesystem;
+
+import androidx.core.content.FileProvider;
+
+public class FileSystemProvider extends FileProvider {
+}

package/android/src/main/res/xml/file_provider_paths.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+  <external-path name="external" path="." />
+  <external-files-path name="external_files" path="." />
+  <external-cache-path name="external_cache" path="." />
+  <files-path name="files" path="." />
+  <cache-path name="cache" path="." />
+</paths>

package/dist/FileSystem.d.ts

@@ -0,0 +1,63 @@
+import { IFileInfo, TStorage } from "./IFileSystemPlugin";
+/**
+ * 파일 시스템 접근 플러그인
+ * - Android 11+: MANAGE_EXTERNAL_STORAGE 권한으로 전체 파일 시스템 접근
+ * - Android 10-: READ/WRITE_EXTERNAL_STORAGE 권한
+ * - Browser: IndexedDB 기반 에뮬레이션
+ */
+export declare abstract class FileSystem {
+    /**
+     * 권한 확인
+     */
+    static checkPermissionAsync(): Promise<boolean>;
+    /**
+     * 권한 요청
+     * - Android 11+: 설정 화면으로 이동
+     * - Android 10-: 권한 다이얼로그 표시
+     */
+    static requestPermissionAsync(): Promise<void>;
+    /**
+     * 디렉토리 읽기
+     */
+    static readdirAsync(dirPath: string): Promise<IFileInfo[]>;
+    /**
+     * 저장소 경로 얻기
+     * @param type 저장소 타입
+     * - external: 외부 저장소 루트 (Environment.getExternalStorageDirectory)
+     * - externalFiles: 앱 전용 외부 파일 디렉토리
+     * - externalCache: 앱 전용 외부 캐시 디렉토리
+     * - externalMedia: 앱 전용 외부 미디어 디렉토리
+     * - appData: 앱 데이터 디렉토리
+     * - appFiles: 앱 파일 디렉토리
+     * - appCache: 앱 캐시 디렉토리
+     */
+    static getStoragePathAsync(type: TStorage): Promise<string>;
+    /**
+     * 파일 URI 얻기 (FileProvider)
+     */
+    static getFileUriAsync(filePath: string): Promise<string>;
+    /**
+     * 파일 쓰기
+     */
+    static writeFileAsync(filePath: string, data: string | Buffer): Promise<void>;
+    /**
+     * 파일 읽기 (UTF-8 문자열)
+     */
+    static readFileStringAsync(filePath: string): Promise<string>;
+    /**
+     * 파일 읽기 (Buffer)
+     */
+    static readFileBufferAsync(filePath: string): Promise<Buffer>;
+    /**
+     * 파일/디렉토리 삭제 (재귀)
+     */
+    static removeAsync(targetPath: string): Promise<void>;
+    /**
+     * 디렉토리 생성 (재귀)
+     */
+    static mkdirsAsync(targetPath: string): Promise<void>;
+    /**
+     * 존재 여부 확인
+     */
+    static existsAsync(targetPath: string): Promise<boolean>;
+}

package/dist/FileSystem.js

@@ -0,0 +1,111 @@
+import { registerPlugin } from "@capacitor/core";
+const FileSystemPlugin = registerPlugin("FileSystem", {
+    web: async () => {
+        const { FileSystemWeb } = await import("./web/FileSystemWeb");
+        return new FileSystemWeb();
+    },
+});
+/**
+ * 파일 시스템 접근 플러그인
+ * - Android 11+: MANAGE_EXTERNAL_STORAGE 권한으로 전체 파일 시스템 접근
+ * - Android 10-: READ/WRITE_EXTERNAL_STORAGE 권한
+ * - Browser: IndexedDB 기반 에뮬레이션
+ */
+export class FileSystem {
+    /**
+     * 권한 확인
+     */
+    static async checkPermissionAsync() {
+        const result = await FileSystemPlugin.checkPermission();
+        return result.granted;
+    }
+    /**
+     * 권한 요청
+     * - Android 11+: 설정 화면으로 이동
+     * - Android 10-: 권한 다이얼로그 표시
+     */
+    static async requestPermissionAsync() {
+        await FileSystemPlugin.requestPermission();
+    }
+    /**
+     * 디렉토리 읽기
+     */
+    static async readdirAsync(dirPath) {
+        const result = await FileSystemPlugin.readdir({ path: dirPath });
+        return result.files;
+    }
+    /**
+     * 저장소 경로 얻기
+     * @param type 저장소 타입
+     * - external: 외부 저장소 루트 (Environment.getExternalStorageDirectory)
+     * - externalFiles: 앱 전용 외부 파일 디렉토리
+     * - externalCache: 앱 전용 외부 캐시 디렉토리
+     * - externalMedia: 앱 전용 외부 미디어 디렉토리
+     * - appData: 앱 데이터 디렉토리
+     * - appFiles: 앱 파일 디렉토리
+     * - appCache: 앱 캐시 디렉토리
+     */
+    static async getStoragePathAsync(type) {
+        const result = await FileSystemPlugin.getStoragePath({ type });
+        return result.path;
+    }
+    /**
+     * 파일 URI 얻기 (FileProvider)
+     */
+    static async getFileUriAsync(filePath) {
+        const result = await FileSystemPlugin.getFileUri({ path: filePath });
+        return result.uri;
+    }
+    /**
+     * 파일 쓰기
+     */
+    static async writeFileAsync(filePath, data) {
+        if (Buffer.isBuffer(data)) {
+            await FileSystemPlugin.writeFile({
+                path: filePath,
+                data: data.toString("base64"),
+                encoding: "base64",
+            });
+        }
+        else {
+            await FileSystemPlugin.writeFile({
+                path: filePath,
+                data,
+                encoding: "utf8",
+            });
+        }
+    }
+    /**
+     * 파일 읽기 (UTF-8 문자열)
+     */
+    static async readFileStringAsync(filePath) {
+        const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "utf8" });
+        return result.data;
+    }
+    /**
+     * 파일 읽기 (Buffer)
+     */
+    static async readFileBufferAsync(filePath) {
+        const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "base64" });
+        return Buffer.from(result.data, "base64");
+    }
+    /**
+     * 파일/디렉토리 삭제 (재귀)
+     */
+    static async removeAsync(targetPath) {
+        await FileSystemPlugin.remove({ path: targetPath });
+    }
+    /**
+     * 디렉토리 생성 (재귀)
+     */
+    static async mkdirsAsync(targetPath) {
+        await FileSystemPlugin.mkdir({ path: targetPath });
+    }
+    /**
+     * 존재 여부 확인
+     */
+    static async existsAsync(targetPath) {
+        const result = await FileSystemPlugin.exists({ path: targetPath });
+        return result.exists;
+    }
+}

package/dist/IFileSystemPlugin.d.ts

@@ -0,0 +1,48 @@
+export type TStorage = "external" | "externalFiles" | "externalCache" | "externalMedia" | "appData" | "appFiles" | "appCache";
+export interface IFileInfo {
+    name: string;
+    isDirectory: boolean;
+}
+export interface IFileSystemPlugin {
+    checkPermission(): Promise<{
+        granted: boolean;
+    }>;
+    requestPermission(): Promise<void>;
+    readdir(options: {
+        path: string;
+    }): Promise<{
+        files: IFileInfo[];
+    }>;
+    getStoragePath(options: {
+        type: TStorage;
+    }): Promise<{
+        path: string;
+    }>;
+    getFileUri(options: {
+        path: string;
+    }): Promise<{
+        uri: string;
+    }>;
+    writeFile(options: {
+        path: string;
+        data: string;
+        encoding?: "utf8" | "base64";
+    }): Promise<void>;
+    readFile(options: {
+        path: string;
+        encoding?: "utf8" | "base64";
+    }): Promise<{
+        data: string;
+    }>;
+    remove(options: {
+        path: string;
+    }): Promise<void>;
+    mkdir(options: {
+        path: string;
+    }): Promise<void>;
+    exists(options: {
+        path: string;
+    }): Promise<{
+        exists: boolean;
+    }>;
+}

package/dist/IFileSystemPlugin.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./FileSystem";
+export * from "./IFileSystemPlugin";
+export * from "./web/FileSystemWeb";
+export * from "./web/VirtualFileSystem";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./FileSystem";
+export * from "./IFileSystemPlugin";
+export * from "./web/FileSystemWeb";
+export * from "./web/VirtualFileSystem";

package/dist/web/FileSystemWeb.d.ts

@@ -0,0 +1,46 @@
+import { WebPlugin } from "@capacitor/core";
+import { IFileInfo, IFileSystemPlugin, TStorage } from "../IFileSystemPlugin";
+export declare class FileSystemWeb extends WebPlugin implements IFileSystemPlugin {
+    private readonly _fs;
+    checkPermission(): Promise<{
+        granted: boolean;
+    }>;
+    requestPermission(): Promise<void>;
+    readdir(options: {
+        path: string;
+    }): Promise<{
+        files: IFileInfo[];
+    }>;
+    getStoragePath(options: {
+        type: TStorage;
+    }): Promise<{
+        path: string;
+    }>;
+    getFileUri(options: {
+        path: string;
+    }): Promise<{
+        uri: string;
+    }>;
+    writeFile(options: {
+        path: string;
+        data: string;
+        encoding?: "utf8" | "base64";
+    }): Promise<void>;
+    readFile(options: {
+        path: string;
+        encoding?: "utf8" | "base64";
+    }): Promise<{
+        data: string;
+    }>;
+    remove(options: {
+        path: string;
+    }): Promise<void>;
+    mkdir(options: {
+        path: string;
+    }): Promise<void>;
+    exists(options: {
+        path: string;
+    }): Promise<{
+        exists: boolean;
+    }>;
+}

package/dist/web/FileSystemWeb.js

@@ -0,0 +1,91 @@
+import { WebPlugin } from "@capacitor/core";
+import { VirtualFileSystem } from "./VirtualFileSystem";
+import path from "path";
+export class FileSystemWeb extends WebPlugin {
+    constructor() {
+        super(...arguments);
+        this._fs = new VirtualFileSystem("capacitor_web_virtual_fs");
+    }
+    async checkPermission() {
+        return await Promise.resolve({ granted: true });
+    }
+    async requestPermission() { }
+    async readdir(options) {
+        const entry = await this._fs.getEntry(options.path);
+        if (!entry || entry.kind !== "dir") {
+            throw new Error("Directory does not exist");
+        }
+        const files = await this._fs.listChildren(options.path);
+        return { files };
+    }
+    async getStoragePath(options) {
+        const base = "/webfs";
+        let storagePath;
+        switch (options.type) {
+            case "external":
+                storagePath = base + "/external";
+                break;
+            case "externalFiles":
+                storagePath = base + "/externalFiles";
+                break;
+            case "externalCache":
+                storagePath = base + "/externalCache";
+                break;
+            case "externalMedia":
+                storagePath = base + "/externalMedia";
+                break;
+            case "appData":
+                storagePath = base + "/appData";
+                break;
+            case "appFiles":
+                storagePath = base + "/appFiles";
+                break;
+            case "appCache":
+                storagePath = base + "/appCache";
+                break;
+            default:
+                throw new Error("Unknown storage type: " + options.type);
+        }
+        await this._fs.ensureDir(storagePath);
+        return { path: storagePath };
+    }
+    async getFileUri(options) {
+        const entry = await this._fs.getEntry(options.path);
+        if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
+            throw new Error("File not found: " + options.path);
+        }
+        const byteCharacters = atob(entry.dataBase64);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const blob = new Blob([new Uint8Array(byteNumbers)]);
+        return { uri: URL.createObjectURL(blob) };
+    }
+    async writeFile(options) {
+        await this._fs.ensureDir(path.dirname(options.path));
+        const dataBase64 = options.encoding === "base64" ? options.data : btoa(options.data);
+        await this._fs.putEntry({ path: options.path, kind: "file", dataBase64 });
+    }
+    async readFile(options) {
+        const entry = await this._fs.getEntry(options.path);
+        if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
+            throw new Error("File not found: " + options.path);
+        }
+        const data = options.encoding === "base64" ? entry.dataBase64 : atob(entry.dataBase64);
+        return { data };
+    }
+    async remove(options) {
+        const ok = await this._fs.deleteByPrefix(options.path);
+        if (!ok) {
+            throw new Error("Deletion failed");
+        }
+    }
+    async mkdir(options) {
+        await this._fs.ensureDir(options.path);
+    }
+    async exists(options) {
+        const entry = await this._fs.getEntry(options.path);
+        return { exists: !!entry };
+    }
+}

package/dist/web/VirtualFileSystem.d.ts

@@ -0,0 +1,20 @@
+import { IFileInfo } from "../IFileSystemPlugin";
+interface FsEntry {
+    path: string;
+    kind: "file" | "dir";
+    dataBase64?: string;
+}
+export declare class VirtualFileSystem {
+    private readonly _dbName;
+    private readonly _STORE_NAME;
+    private readonly _DB_VERSION;
+    constructor(_dbName: string);
+    private _openDb;
+    private _withStore;
+    getEntry(filePath: string): Promise<FsEntry | undefined>;
+    putEntry(entry: FsEntry): Promise<void>;
+    deleteByPrefix(pathPrefix: string): Promise<boolean>;
+    listChildren(dirPath: string): Promise<IFileInfo[]>;
+    ensureDir(dirPath: string): Promise<void>;
+}
+export {};

package/dist/web/VirtualFileSystem.js

@@ -0,0 +1,119 @@
+export class VirtualFileSystem {
+    constructor(_dbName) {
+        this._dbName = _dbName;
+        this._STORE_NAME = "entries";
+        this._DB_VERSION = 1;
+    }
+    async _openDb() {
+        return await new Promise((resolve, reject) => {
+            const req = indexedDB.open(this._dbName, this._DB_VERSION);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains(this._STORE_NAME)) {
+                    db.createObjectStore(this._STORE_NAME, { keyPath: "path" });
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async _withStore(mode, fn) {
+        const db = await this._openDb();
+        return await new Promise((resolve, reject) => {
+            const tx = db.transaction(this._STORE_NAME, mode);
+            const store = tx.objectStore(this._STORE_NAME);
+            let result;
+            Promise.resolve(fn(store))
+                .then((r) => {
+                result = r;
+            })
+                .catch(reject);
+            tx.oncomplete = () => resolve(result);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async getEntry(filePath) {
+        return await this._withStore("readonly", async (store) => {
+            return await new Promise((resolve, reject) => {
+                const req = store.get(filePath);
+                req.onsuccess = () => resolve(req.result);
+                req.onerror = () => reject(req.error);
+            });
+        });
+    }
+    async putEntry(entry) {
+        return await this._withStore("readwrite", async (store) => {
+            return await new Promise((resolve, reject) => {
+                const req = store.put(entry);
+                req.onsuccess = () => resolve();
+                req.onerror = () => reject(req.error);
+            });
+        });
+    }
+    async deleteByPrefix(pathPrefix) {
+        return await this._withStore("readwrite", async (store) => {
+            return await new Promise((resolve, reject) => {
+                const req = store.openCursor();
+                let found = false;
+                req.onsuccess = () => {
+                    const cursor = req.result;
+                    if (!cursor) {
+                        resolve(found);
+                        return;
+                    }
+                    const key = String(cursor.key);
+                    if (key === pathPrefix || key.startsWith(pathPrefix + "/")) {
+                        found = true;
+                        cursor.delete();
+                    }
+                    cursor.continue();
+                };
+                req.onerror = () => reject(req.error);
+            });
+        });
+    }
+    async listChildren(dirPath) {
+        const prefix = dirPath === "/" ? "/" : dirPath + "/";
+        return await this._withStore("readonly", async (store) => {
+            return await new Promise((resolve, reject) => {
+                const req = store.openCursor();
+                const map = new Map();
+                req.onsuccess = () => {
+                    const cursor = req.result;
+                    if (!cursor) {
+                        resolve(Array.from(map.entries()).map(([name, isDirectory]) => ({ name, isDirectory })));
+                        return;
+                    }
+                    const key = String(cursor.key);
+                    if (key.startsWith(prefix)) {
+                        const rest = key.slice(prefix.length);
+                        if (rest) {
+                            const firstSeg = rest.split("/")[0];
+                            if (firstSeg && !map.has(firstSeg)) {
+                                const value = cursor.value;
+                                map.set(firstSeg, value.kind === "dir");
+                            }
+                        }
+                    }
+                    cursor.continue();
+                };
+                req.onerror = () => reject(req.error);
+            });
+        });
+    }
+    async ensureDir(dirPath) {
+        if (dirPath === "/") {
+            await this.putEntry({ path: "/", kind: "dir" });
+            return;
+        }
+        const segments = dirPath.split("/").filter(Boolean);
+        let acc = "";
+        for (const seg of segments) {
+            acc += "/" + seg;
+            const existing = await this.getEntry(acc);
+            if (!existing) {
+                await this.putEntry({ path: acc, kind: "dir" });
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@simplysm/capacitor-plugin-file-system",
+  "version": "12.15.69",
+  "description": "심플리즘 패키지 - Capacitor File System Plugin",
+  "author": "김석래",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kslhunter/simplysm.git",
+    "directory": "packages/capacitor-plugin-file-system"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "capacitor": {
+    "android": {
+      "src": "android"
+    }
+  },
+  "dependencies": {
+    "@capacitor/core": "^7.4.4"
+  }
+}

package/src/FileSystem.ts

@@ -0,0 +1,123 @@
+import { registerPlugin } from "@capacitor/core";
+import { IFileInfo, IFileSystemPlugin, TStorage } from "./IFileSystemPlugin";
+
+const FileSystemPlugin = registerPlugin<IFileSystemPlugin>("FileSystem", {
+  web: async () => {
+    const { FileSystemWeb } = await import("./web/FileSystemWeb");
+    return new FileSystemWeb();
+  },
+});
+
+/**
+ * 파일 시스템 접근 플러그인
+ * - Android 11+: MANAGE_EXTERNAL_STORAGE 권한으로 전체 파일 시스템 접근
+ * - Android 10-: READ/WRITE_EXTERNAL_STORAGE 권한
+ * - Browser: IndexedDB 기반 에뮬레이션
+ */
+export abstract class FileSystem {
+  /**
+   * 권한 확인
+   */
+  static async checkPermissionAsync(): Promise<boolean> {
+    const result = await FileSystemPlugin.checkPermission();
+    return result.granted;
+  }
+
+  /**
+   * 권한 요청
+   * - Android 11+: 설정 화면으로 이동
+   * - Android 10-: 권한 다이얼로그 표시
+   */
+  static async requestPermissionAsync(): Promise<void> {
+    await FileSystemPlugin.requestPermission();
+  }
+
+  /**
+   * 디렉토리 읽기
+   */
+  static async readdirAsync(dirPath: string): Promise<IFileInfo[]> {
+    const result = await FileSystemPlugin.readdir({ path: dirPath });
+    return result.files;
+  }
+
+  /**
+   * 저장소 경로 얻기
+   * @param type 저장소 타입
+   * - external: 외부 저장소 루트 (Environment.getExternalStorageDirectory)
+   * - externalFiles: 앱 전용 외부 파일 디렉토리
+   * - externalCache: 앱 전용 외부 캐시 디렉토리
+   * - externalMedia: 앱 전용 외부 미디어 디렉토리
+   * - appData: 앱 데이터 디렉토리
+   * - appFiles: 앱 파일 디렉토리
+   * - appCache: 앱 캐시 디렉토리
+   */
+  static async getStoragePathAsync(type: TStorage): Promise<string> {
+    const result = await FileSystemPlugin.getStoragePath({ type });
+    return result.path;
+  }
+
+  /**
+   * 파일 URI 얻기 (FileProvider)
+   */
+  static async getFileUriAsync(filePath: string): Promise<string> {
+    const result = await FileSystemPlugin.getFileUri({ path: filePath });
+    return result.uri;
+  }
+
+  /**
+   * 파일 쓰기
+   */
+  static async writeFileAsync(filePath: string, data: string | Buffer): Promise<void> {
+    if (Buffer.isBuffer(data)) {
+      await FileSystemPlugin.writeFile({
+        path: filePath,
+        data: data.toString("base64"),
+        encoding: "base64",
+      });
+    } else {
+      await FileSystemPlugin.writeFile({
+        path: filePath,
+        data,
+        encoding: "utf8",
+      });
+    }
+  }
+
+  /**
+   * 파일 읽기 (UTF-8 문자열)
+   */
+  static async readFileStringAsync(filePath: string): Promise<string> {
+    const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "utf8" });
+    return result.data;
+  }
+
+  /**
+   * 파일 읽기 (Buffer)
+   */
+  static async readFileBufferAsync(filePath: string): Promise<Buffer> {
+    const result = await FileSystemPlugin.readFile({ path: filePath, encoding: "base64" });
+    return Buffer.from(result.data, "base64");
+  }
+
+  /**
+   * 파일/디렉토리 삭제 (재귀)
+   */
+  static async removeAsync(targetPath: string): Promise<void> {
+    await FileSystemPlugin.remove({ path: targetPath });
+  }
+
+  /**
+   * 디렉토리 생성 (재귀)
+   */
+  static async mkdirsAsync(targetPath: string): Promise<void> {
+    await FileSystemPlugin.mkdir({ path: targetPath });
+  }
+
+  /**
+   * 존재 여부 확인
+   */
+  static async existsAsync(targetPath: string): Promise<boolean> {
+    const result = await FileSystemPlugin.exists({ path: targetPath });
+    return result.exists;
+  }
+}

package/src/IFileSystemPlugin.ts

@@ -0,0 +1,26 @@
+export type TStorage =
+  | "external"
+  | "externalFiles"
+  | "externalCache"
+  | "externalMedia"
+  | "appData"
+  | "appFiles"
+  | "appCache";
+
+export interface IFileInfo {
+  name: string;
+  isDirectory: boolean;
+}
+
+export interface IFileSystemPlugin {
+  checkPermission(): Promise<{ granted: boolean }>;
+  requestPermission(): Promise<void>;
+  readdir(options: { path: string }): Promise<{ files: IFileInfo[] }>;
+  getStoragePath(options: { type: TStorage }): Promise<{ path: string }>;
+  getFileUri(options: { path: string }): Promise<{ uri: string }>;
+  writeFile(options: { path: string; data: string; encoding?: "utf8" | "base64" }): Promise<void>;
+  readFile(options: { path: string; encoding?: "utf8" | "base64" }): Promise<{ data: string }>;
+  remove(options: { path: string }): Promise<void>;
+  mkdir(options: { path: string }): Promise<void>;
+  exists(options: { path: string }): Promise<{ exists: boolean }>;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./FileSystem";
+export * from "./IFileSystemPlugin";
+export * from "./web/FileSystemWeb";
+export * from "./web/VirtualFileSystem";

package/src/web/FileSystemWeb.ts

@@ -0,0 +1,107 @@
+import { WebPlugin } from "@capacitor/core";
+import { IFileInfo, IFileSystemPlugin, TStorage } from "../IFileSystemPlugin";
+import { VirtualFileSystem } from "./VirtualFileSystem";
+import path from "path";
+
+export class FileSystemWeb extends WebPlugin implements IFileSystemPlugin {
+  private readonly _fs = new VirtualFileSystem("capacitor_web_virtual_fs");
+
+  async checkPermission(): Promise<{ granted: boolean }> {
+    return await Promise.resolve({ granted: true });
+  }
+
+  async requestPermission(): Promise<void> {}
+
+  async readdir(options: { path: string }): Promise<{ files: IFileInfo[] }> {
+    const entry = await this._fs.getEntry(options.path);
+    if (!entry || entry.kind !== "dir") {
+      throw new Error("Directory does not exist");
+    }
+    const files = await this._fs.listChildren(options.path);
+    return { files };
+  }
+
+  async getStoragePath(options: { type: TStorage }): Promise<{ path: string }> {
+    const base = "/webfs";
+    let storagePath: string;
+    switch (options.type) {
+      case "external":
+        storagePath = base + "/external";
+        break;
+      case "externalFiles":
+        storagePath = base + "/externalFiles";
+        break;
+      case "externalCache":
+        storagePath = base + "/externalCache";
+        break;
+      case "externalMedia":
+        storagePath = base + "/externalMedia";
+        break;
+      case "appData":
+        storagePath = base + "/appData";
+        break;
+      case "appFiles":
+        storagePath = base + "/appFiles";
+        break;
+      case "appCache":
+        storagePath = base + "/appCache";
+        break;
+      default:
+        throw new Error("Unknown storage type: " + options.type);
+    }
+    await this._fs.ensureDir(storagePath);
+    return { path: storagePath };
+  }
+
+  async getFileUri(options: { path: string }): Promise<{ uri: string }> {
+    const entry = await this._fs.getEntry(options.path);
+    if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
+      throw new Error("File not found: " + options.path);
+    }
+    const byteCharacters = atob(entry.dataBase64);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const blob = new Blob([new Uint8Array(byteNumbers)]);
+    return { uri: URL.createObjectURL(blob) };
+  }
+
+  async writeFile(options: {
+    path: string;
+    data: string;
+    encoding?: "utf8" | "base64";
+  }): Promise<void> {
+    await this._fs.ensureDir(path.dirname(options.path));
+    const dataBase64 = options.encoding === "base64" ? options.data : btoa(options.data);
+    await this._fs.putEntry({ path: options.path, kind: "file", dataBase64 });
+  }
+
+  async readFile(options: {
+    path: string;
+    encoding?: "utf8" | "base64";
+  }): Promise<{ data: string }> {
+    const entry = await this._fs.getEntry(options.path);
+    if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
+      throw new Error("File not found: " + options.path);
+    }
+    const data = options.encoding === "base64" ? entry.dataBase64 : atob(entry.dataBase64);
+    return { data };
+  }
+
+  async remove(options: { path: string }): Promise<void> {
+    const ok = await this._fs.deleteByPrefix(options.path);
+    if (!ok) {
+      throw new Error("Deletion failed");
+    }
+  }
+
+  async mkdir(options: { path: string }): Promise<void> {
+    await this._fs.ensureDir(options.path);
+  }
+
+  async exists(options: { path: string }): Promise<{ exists: boolean }> {
+    const entry = await this._fs.getEntry(options.path);
+    return { exists: !!entry };
+  }
+}

package/src/web/VirtualFileSystem.ts

@@ -0,0 +1,138 @@
+import { IFileInfo } from "../IFileSystemPlugin";
+
+interface FsEntry {
+  path: string;
+  kind: "file" | "dir";
+  dataBase64?: string;
+}
+
+export class VirtualFileSystem {
+  private readonly _STORE_NAME = "entries";
+  private readonly _DB_VERSION = 1;
+
+  constructor(private readonly _dbName: string) {}
+
+  private async _openDb(): Promise<IDBDatabase> {
+    return await new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, this._DB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(this._STORE_NAME)) {
+          db.createObjectStore(this._STORE_NAME, { keyPath: "path" });
+        }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  private async _withStore<T>(
+    mode: IDBTransactionMode,
+    fn: (store: IDBObjectStore) => Promise<T>,
+  ): Promise<T> {
+    const db = await this._openDb();
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(this._STORE_NAME, mode);
+      const store = tx.objectStore(this._STORE_NAME);
+      let result: T;
+      Promise.resolve(fn(store))
+        .then((r) => {
+          result = r;
+        })
+        .catch(reject);
+      tx.oncomplete = () => resolve(result);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async getEntry(filePath: string): Promise<FsEntry | undefined> {
+    return await this._withStore("readonly", async (store) => {
+      return await new Promise((resolve, reject) => {
+        const req = store.get(filePath);
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async putEntry(entry: FsEntry): Promise<void> {
+    return await this._withStore("readwrite", async (store) => {
+      return await new Promise((resolve, reject) => {
+        const req = store.put(entry);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async deleteByPrefix(pathPrefix: string): Promise<boolean> {
+    return await this._withStore("readwrite", async (store) => {
+      return await new Promise((resolve, reject) => {
+        const req = store.openCursor();
+        let found = false;
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) {
+            resolve(found);
+            return;
+          }
+          const key = String(cursor.key);
+          if (key === pathPrefix || key.startsWith(pathPrefix + "/")) {
+            found = true;
+            cursor.delete();
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async listChildren(dirPath: string): Promise<IFileInfo[]> {
+    const prefix = dirPath === "/" ? "/" : dirPath + "/";
+    return await this._withStore("readonly", async (store) => {
+      return await new Promise((resolve, reject) => {
+        const req = store.openCursor();
+        const map = new Map<string, boolean>();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) {
+            resolve(
+              Array.from(map.entries()).map(([name, isDirectory]) => ({ name, isDirectory })),
+            );
+            return;
+          }
+          const key = String(cursor.key);
+          if (key.startsWith(prefix)) {
+            const rest = key.slice(prefix.length);
+            if (rest) {
+              const firstSeg = rest.split("/")[0];
+              if (firstSeg && !map.has(firstSeg)) {
+                const value = cursor.value as FsEntry;
+                map.set(firstSeg, value.kind === "dir");
+              }
+            }
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async ensureDir(dirPath: string): Promise<void> {
+    if (dirPath === "/") {
+      await this.putEntry({ path: "/", kind: "dir" });
+      return;
+    }
+    const segments = dirPath.split("/").filter(Boolean);
+    let acc = "";
+    for (const seg of segments) {
+      acc += "/" + seg;
+      const existing = await this.getEntry(acc);
+      if (!existing) {
+        await this.putEntry({ path: acc, kind: "dir" });
+      }
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": ["ES2021", "DOM"],
+    "outDir": "./dist"
+  },
+  "exclude": ["dist", "node_modules"]
+}