@simplysm/capacitor-plugin-usb-storage 12.15.69

package/android/build.gradle

@@ -0,0 +1,10 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "kr.co.simplysm.capacitor.usbstorage"
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+    implementation 'me.jahnen.libaums:core:0.9.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/kr/co/simplysm/capacitor/usbstorage/UsbStoragePlugin.java

@@ -0,0 +1,263 @@
+package kr.co.simplysm.capacitor.usbstorage;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbManager;
+import android.os.Build;
+import android.util.Base64;
+import android.util.Log;
+
+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.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Optional;
+
+import me.jahnen.libaums.core.UsbMassStorageDevice;
+import me.jahnen.libaums.core.fs.FileSystem;
+import me.jahnen.libaums.core.fs.UsbFile;
+import me.jahnen.libaums.core.fs.UsbFileInputStream;
+
+@CapacitorPlugin(name = "UsbStorage")
+public class UsbStoragePlugin extends Plugin {
+
+    private static final String TAG = "UsbStoragePlugin";
+    private static final String ACTION_USB_PERMISSION = "kr.co.simplysm.capacitor.usbstorage.USB_PERMISSION";
+
+    @PluginMethod
+    public void getDevices(PluginCall call) {
+        try {
+            UsbMassStorageDevice[] devices = UsbMassStorageDevice.getMassStorageDevices(getContext());
+
+            JSArray result = new JSArray();
+            for (UsbMassStorageDevice device : devices) {
+                UsbDevice usbDevice = device.getUsbDevice();
+
+                JSObject deviceObj = new JSObject();
+                deviceObj.put("deviceName", usbDevice.getDeviceName());
+                deviceObj.put("manufacturerName", usbDevice.getManufacturerName());
+                deviceObj.put("productName", usbDevice.getProductName());
+                deviceObj.put("vendorId", usbDevice.getVendorId());
+                deviceObj.put("productId", usbDevice.getProductId());
+                result.put(deviceObj);
+            }
+
+            JSObject ret = new JSObject();
+            ret.put("devices", result);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "getDevices failed", e);
+            call.reject("getDevices failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void requestPermission(PluginCall call) {
+        Integer vendorId = call.getInt("vendorId");
+        Integer productId = call.getInt("productId");
+
+        if (vendorId == null || productId == null) {
+            call.reject("vendorId and productId are required");
+            return;
+        }
+
+        try {
+            UsbMassStorageDevice device = getDevice(vendorId, productId);
+            UsbDevice usbDevice = device.getUsbDevice();
+
+            UsbManager usbManager = (UsbManager) getContext().getSystemService(Context.USB_SERVICE);
+            if (usbManager.hasPermission(usbDevice)) {
+                JSObject ret = new JSObject();
+                ret.put("granted", true);
+                call.resolve(ret);
+                return;
+            }
+
+            BroadcastReceiver receiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    try {
+                        context.unregisterReceiver(this);
+                        boolean granted = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
+                        JSObject ret = new JSObject();
+                        ret.put("granted", granted);
+                        call.resolve(ret);
+                    } catch (Exception e) {
+                        Log.e(TAG, "requestPermission callback failed", e);
+                        call.reject("requestPermission failed: " + e.getMessage());
+                    }
+                }
+            };
+
+            IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                getContext().registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED);
+            } else {
+                getContext().registerReceiver(receiver, filter);
+            }
+
+            int flags = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                ? PendingIntent.FLAG_MUTABLE
+                : 0;
+            PendingIntent permissionIntent = PendingIntent.getBroadcast(
+                getContext(), 0, new Intent(ACTION_USB_PERMISSION), flags
+            );
+            usbManager.requestPermission(usbDevice, permissionIntent);
+        } catch (Exception e) {
+            Log.e(TAG, "requestPermission failed", e);
+            call.reject("requestPermission failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void hasPermission(PluginCall call) {
+        Integer vendorId = call.getInt("vendorId");
+        Integer productId = call.getInt("productId");
+
+        if (vendorId == null || productId == null) {
+            call.reject("vendorId and productId are required");
+            return;
+        }
+
+        try {
+            UsbMassStorageDevice device = getDevice(vendorId, productId);
+            UsbManager usbManager = (UsbManager) getContext().getSystemService(Context.USB_SERVICE);
+            boolean hasPermission = usbManager.hasPermission(device.getUsbDevice());
+
+            JSObject ret = new JSObject();
+            ret.put("granted", hasPermission);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "hasPermission failed", e);
+            call.reject("hasPermission failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void readdir(PluginCall call) {
+        Integer vendorId = call.getInt("vendorId");
+        Integer productId = call.getInt("productId");
+        String path = call.getString("path");
+
+        if (vendorId == null || productId == null || path == null) {
+            call.reject("vendorId, productId, and path are required");
+            return;
+        }
+
+        try {
+            UsbMassStorageDevice device = getDevice(vendorId, productId);
+
+            UsbManager usbManager = (UsbManager) getContext().getSystemService(Context.USB_SERVICE);
+            if (!usbManager.hasPermission(device.getUsbDevice())) {
+                call.reject("USB 장치에 대한 접근 권한이 없습니다.");
+                return;
+            }
+
+            device.init();
+
+            FileSystem fs = device.getPartitions().get(0).getFileSystem();
+            UsbFile root = fs.getRootDirectory();
+            UsbFile dir = root.search(path);
+
+            if (dir == null || !dir.isDirectory()) {
+                call.reject("Directory not found: " + path);
+                return;
+            }
+
+            UsbFile[] files = dir.listFiles();
+
+            JSArray result = new JSArray();
+            for (UsbFile file : files) {
+                result.put(file.getName());
+            }
+
+            JSObject ret = new JSObject();
+            ret.put("files", result);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "readdir failed", e);
+            call.reject("readdir failed: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void read(PluginCall call) {
+        Integer vendorId = call.getInt("vendorId");
+        Integer productId = call.getInt("productId");
+        String path = call.getString("path");
+
+        if (vendorId == null || productId == null || path == null) {
+            call.reject("vendorId, productId, and path are required");
+            return;
+        }
+
+        try {
+            UsbMassStorageDevice device = getDevice(vendorId, productId);
+
+            UsbManager usbManager = (UsbManager) getContext().getSystemService(Context.USB_SERVICE);
+            if (!usbManager.hasPermission(device.getUsbDevice())) {
+                call.reject("USB 장치에 대한 접근 권한이 없습니다.");
+                return;
+            }
+
+            device.init();
+
+            FileSystem fs = device.getPartitions().get(0).getFileSystem();
+            UsbFile root = fs.getRootDirectory();
+            UsbFile usbFile = root.search(path);
+
+            if (usbFile == null) {
+                JSObject ret = new JSObject();
+                ret.put("data", (String) null);
+                call.resolve(ret);
+                return;
+            }
+
+            if (usbFile.isDirectory()) {
+                call.reject("해당 경로는 폴더입니다.");
+                return;
+            }
+
+            ByteBuffer buffer = ByteBuffer.allocate((int) usbFile.getLength());
+
+            UsbFileInputStream inputStream = new UsbFileInputStream(usbFile);
+            byte[] tmpBuf = new byte[fs.getChunkSize()];
+            int count;
+            while ((count = inputStream.read(tmpBuf)) != -1) {
+                buffer.put(tmpBuf, 0, count);
+            }
+            inputStream.close();
+
+            String base64Data = Base64.encodeToString(buffer.array(), Base64.NO_WRAP);
+
+            JSObject ret = new JSObject();
+            ret.put("data", base64Data);
+            call.resolve(ret);
+        } catch (Exception e) {
+            Log.e(TAG, "read failed", e);
+            call.reject("read failed: " + e.getMessage());
+        }
+    }
+
+    private UsbMassStorageDevice getDevice(int vendorId, int productId) throws Exception {
+        UsbMassStorageDevice[] devices = UsbMassStorageDevice.getMassStorageDevices(getContext());
+        Optional<UsbMassStorageDevice> optDevice = Arrays.stream(devices).filter((tmpDevice) -> {
+            UsbDevice tmpUsbDevice = tmpDevice.getUsbDevice();
+            return tmpUsbDevice.getVendorId() == vendorId && tmpUsbDevice.getProductId() == productId;
+        }).findFirst();
+
+        if (!optDevice.isPresent()) {
+            throw new Exception("USB 장치를 찾을 수 없습니다.");
+        }
+        return optDevice.get();
+    }
+}

package/dist/IUsbStoragePlugin.d.ts

@@ -0,0 +1,32 @@
+export interface IUsbDeviceInfo {
+    deviceName: string;
+    manufacturerName: string;
+    productName: string;
+    vendorId: number;
+    productId: number;
+}
+export interface IUsbDeviceFilter {
+    vendorId: number;
+    productId: number;
+}
+export interface IUsbStoragePlugin {
+    getDevices(): Promise<{
+        devices: IUsbDeviceInfo[];
+    }>;
+    requestPermission(options: IUsbDeviceFilter): Promise<{
+        granted: boolean;
+    }>;
+    hasPermission(options: IUsbDeviceFilter): Promise<{
+        granted: boolean;
+    }>;
+    readdir(options: IUsbDeviceFilter & {
+        path: string;
+    }): Promise<{
+        files: string[];
+    }>;
+    read(options: IUsbDeviceFilter & {
+        path: string;
+    }): Promise<{
+        data: string | null;
+    }>;
+}

package/dist/IUsbStoragePlugin.js

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

package/dist/UsbStorage.d.ts

@@ -0,0 +1,51 @@
+import { IUsbDeviceInfo } from "./IUsbStoragePlugin";
+/**
+ * USB 저장장치와 상호작용하기 위한 플러그인
+ * - Android: libaums 라이브러리를 통한 USB Mass Storage 접근
+ * - Browser: alert으로 안내 후 빈 값 반환
+ */
+export declare abstract class UsbStorage {
+    /**
+     * 연결된 USB 장치 목록을 가져옴
+     * @returns 연결된 USB 장치 정보 배열
+     */
+    static getDevices(): Promise<IUsbDeviceInfo[]>;
+    /**
+     * USB 장치 접근 권한을 요청
+     * @param filter 권한을 요청할 USB 장치의 vendorId와 productId
+     * @returns 권한 승인 여부
+     */
+    static requestPermission(filter: {
+        vendorId: number;
+        productId: number;
+    }): Promise<boolean>;
+    /**
+     * USB 장치 접근 권한이 있는지 확인
+     * @param filter 권한을 확인할 USB 장치의 vendorId와 productId
+     * @returns 권한 보유 여부
+     */
+    static hasPermission(filter: {
+        vendorId: number;
+        productId: number;
+    }): Promise<boolean>;
+    /**
+     * USB 저장장치의 디렉토리 내용을 읽어옴
+     * @param filter 대상 USB 장치의 vendorId와 productId
+     * @param dirPath 읽어올 디렉토리 경로
+     * @returns 디렉토리 내 파일/폴더 이름 배열
+     */
+    static readdir(filter: {
+        vendorId: number;
+        productId: number;
+    }, dirPath: string): Promise<string[]>;
+    /**
+     * USB 저장장치의 파일을 읽어옴
+     * @param filter 대상 USB 장치의 vendorId와 productId
+     * @param filePath 읽어올 파일 경로
+     * @returns 파일 데이터를 담은 Buffer 또는 undefined
+     */
+    static read(filter: {
+        vendorId: number;
+        productId: number;
+    }, filePath: string): Promise<Buffer | undefined>;
+}

package/dist/UsbStorage.js

@@ -0,0 +1,63 @@
+import { registerPlugin } from "@capacitor/core";
+const UsbStoragePlugin = registerPlugin("UsbStorage", {
+    web: async () => {
+        const { UsbStorageWeb } = await import("./web/UsbStorageWeb");
+        return new UsbStorageWeb();
+    },
+});
+/**
+ * USB 저장장치와 상호작용하기 위한 플러그인
+ * - Android: libaums 라이브러리를 통한 USB Mass Storage 접근
+ * - Browser: alert으로 안내 후 빈 값 반환
+ */
+export class UsbStorage {
+    /**
+     * 연결된 USB 장치 목록을 가져옴
+     * @returns 연결된 USB 장치 정보 배열
+     */
+    static async getDevices() {
+        const result = await UsbStoragePlugin.getDevices();
+        return result.devices;
+    }
+    /**
+     * USB 장치 접근 권한을 요청
+     * @param filter 권한을 요청할 USB 장치의 vendorId와 productId
+     * @returns 권한 승인 여부
+     */
+    static async requestPermission(filter) {
+        const result = await UsbStoragePlugin.requestPermission(filter);
+        return result.granted;
+    }
+    /**
+     * USB 장치 접근 권한이 있는지 확인
+     * @param filter 권한을 확인할 USB 장치의 vendorId와 productId
+     * @returns 권한 보유 여부
+     */
+    static async hasPermission(filter) {
+        const result = await UsbStoragePlugin.hasPermission(filter);
+        return result.granted;
+    }
+    /**
+     * USB 저장장치의 디렉토리 내용을 읽어옴
+     * @param filter 대상 USB 장치의 vendorId와 productId
+     * @param dirPath 읽어올 디렉토리 경로
+     * @returns 디렉토리 내 파일/폴더 이름 배열
+     */
+    static async readdir(filter, dirPath) {
+        const result = await UsbStoragePlugin.readdir({ ...filter, path: dirPath });
+        return result.files;
+    }
+    /**
+     * USB 저장장치의 파일을 읽어옴
+     * @param filter 대상 USB 장치의 vendorId와 productId
+     * @param filePath 읽어올 파일 경로
+     * @returns 파일 데이터를 담은 Buffer 또는 undefined
+     */
+    static async read(filter, filePath) {
+        const result = await UsbStoragePlugin.read({ ...filter, path: filePath });
+        if (result.data == null) {
+            return undefined;
+        }
+        return Buffer.from(result.data, "base64");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IUsbStoragePlugin";
+export * from "./UsbStorage";
+export * from "./web/UsbStorageWeb";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./IUsbStoragePlugin";
+export * from "./UsbStorage";
+export * from "./web/UsbStorageWeb";

package/dist/web/UsbStorageWeb.d.ts

@@ -0,0 +1,23 @@
+import { WebPlugin } from "@capacitor/core";
+import { IUsbDeviceFilter, IUsbDeviceInfo, IUsbStoragePlugin } from "../IUsbStoragePlugin";
+export declare class UsbStorageWeb extends WebPlugin implements IUsbStoragePlugin {
+    getDevices(): Promise<{
+        devices: IUsbDeviceInfo[];
+    }>;
+    requestPermission(_options: IUsbDeviceFilter): Promise<{
+        granted: boolean;
+    }>;
+    hasPermission(_options: IUsbDeviceFilter): Promise<{
+        granted: boolean;
+    }>;
+    readdir(_options: IUsbDeviceFilter & {
+        path: string;
+    }): Promise<{
+        files: string[];
+    }>;
+    read(_options: IUsbDeviceFilter & {
+        path: string;
+    }): Promise<{
+        data: string | null;
+    }>;
+}

package/dist/web/UsbStorageWeb.js

@@ -0,0 +1,21 @@
+import { WebPlugin } from "@capacitor/core";
+export class UsbStorageWeb extends WebPlugin {
+    async getDevices() {
+        return await Promise.resolve({ devices: [] });
+    }
+    async requestPermission(_options) {
+        alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+        return await Promise.resolve({ granted: false });
+    }
+    async hasPermission(_options) {
+        return await Promise.resolve({ granted: false });
+    }
+    async readdir(_options) {
+        alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+        return await Promise.resolve({ files: [] });
+    }
+    async read(_options) {
+        alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+        return await Promise.resolve({ data: null });
+    }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@simplysm/capacitor-plugin-usb-storage",
+  "version": "12.15.69",
+  "description": "심플리즘 패키지 - Capacitor USB Storage Plugin",
+  "author": "김석래",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kslhunter/simplysm.git",
+    "directory": "packages/capacitor-plugin-usb-storage"
+  },
+  "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/IUsbStoragePlugin.ts

@@ -0,0 +1,20 @@
+export interface IUsbDeviceInfo {
+  deviceName: string;
+  manufacturerName: string;
+  productName: string;
+  vendorId: number;
+  productId: number;
+}
+
+export interface IUsbDeviceFilter {
+  vendorId: number;
+  productId: number;
+}
+
+export interface IUsbStoragePlugin {
+  getDevices(): Promise<{ devices: IUsbDeviceInfo[] }>;
+  requestPermission(options: IUsbDeviceFilter): Promise<{ granted: boolean }>;
+  hasPermission(options: IUsbDeviceFilter): Promise<{ granted: boolean }>;
+  readdir(options: IUsbDeviceFilter & { path: string }): Promise<{ files: string[] }>;
+  read(options: IUsbDeviceFilter & { path: string }): Promise<{ data: string | null }>;
+}

package/src/UsbStorage.ts

@@ -0,0 +1,82 @@
+import { registerPlugin } from "@capacitor/core";
+import { IUsbDeviceInfo, IUsbStoragePlugin } from "./IUsbStoragePlugin";
+
+const UsbStoragePlugin = registerPlugin<IUsbStoragePlugin>("UsbStorage", {
+  web: async () => {
+    const { UsbStorageWeb } = await import("./web/UsbStorageWeb");
+    return new UsbStorageWeb();
+  },
+});
+
+/**
+ * USB 저장장치와 상호작용하기 위한 플러그인
+ * - Android: libaums 라이브러리를 통한 USB Mass Storage 접근
+ * - Browser: alert으로 안내 후 빈 값 반환
+ */
+export abstract class UsbStorage {
+  /**
+   * 연결된 USB 장치 목록을 가져옴
+   * @returns 연결된 USB 장치 정보 배열
+   */
+  static async getDevices(): Promise<IUsbDeviceInfo[]> {
+    const result = await UsbStoragePlugin.getDevices();
+    return result.devices;
+  }
+
+  /**
+   * USB 장치 접근 권한을 요청
+   * @param filter 권한을 요청할 USB 장치의 vendorId와 productId
+   * @returns 권한 승인 여부
+   */
+  static async requestPermission(filter: {
+    vendorId: number;
+    productId: number;
+  }): Promise<boolean> {
+    const result = await UsbStoragePlugin.requestPermission(filter);
+    return result.granted;
+  }
+
+  /**
+   * USB 장치 접근 권한이 있는지 확인
+   * @param filter 권한을 확인할 USB 장치의 vendorId와 productId
+   * @returns 권한 보유 여부
+   */
+  static async hasPermission(filter: {
+    vendorId: number;
+    productId: number;
+  }): Promise<boolean> {
+    const result = await UsbStoragePlugin.hasPermission(filter);
+    return result.granted;
+  }
+
+  /**
+   * USB 저장장치의 디렉토리 내용을 읽어옴
+   * @param filter 대상 USB 장치의 vendorId와 productId
+   * @param dirPath 읽어올 디렉토리 경로
+   * @returns 디렉토리 내 파일/폴더 이름 배열
+   */
+  static async readdir(
+    filter: { vendorId: number; productId: number },
+    dirPath: string,
+  ): Promise<string[]> {
+    const result = await UsbStoragePlugin.readdir({ ...filter, path: dirPath });
+    return result.files;
+  }
+
+  /**
+   * USB 저장장치의 파일을 읽어옴
+   * @param filter 대상 USB 장치의 vendorId와 productId
+   * @param filePath 읽어올 파일 경로
+   * @returns 파일 데이터를 담은 Buffer 또는 undefined
+   */
+  static async read(
+    filter: { vendorId: number; productId: number },
+    filePath: string,
+  ): Promise<Buffer | undefined> {
+    const result = await UsbStoragePlugin.read({ ...filter, path: filePath });
+    if (result.data == null) {
+      return undefined;
+    }
+    return Buffer.from(result.data, "base64");
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./IUsbStoragePlugin";
+export * from "./UsbStorage";
+export * from "./web/UsbStorageWeb";

package/src/web/UsbStorageWeb.ts

@@ -0,0 +1,27 @@
+import { WebPlugin } from "@capacitor/core";
+import { IUsbDeviceFilter, IUsbDeviceInfo, IUsbStoragePlugin } from "../IUsbStoragePlugin";
+
+export class UsbStorageWeb extends WebPlugin implements IUsbStoragePlugin {
+  async getDevices(): Promise<{ devices: IUsbDeviceInfo[] }> {
+    return await Promise.resolve({ devices: [] });
+  }
+
+  async requestPermission(_options: IUsbDeviceFilter): Promise<{ granted: boolean }> {
+    alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+    return await Promise.resolve({ granted: false });
+  }
+
+  async hasPermission(_options: IUsbDeviceFilter): Promise<{ granted: boolean }> {
+    return await Promise.resolve({ granted: false });
+  }
+
+  async readdir(_options: IUsbDeviceFilter & { path: string }): Promise<{ files: string[] }> {
+    alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+    return await Promise.resolve({ files: [] });
+  }
+
+  async read(_options: IUsbDeviceFilter & { path: string }): Promise<{ data: string | null }> {
+    alert("[UsbStorage] 웹 환경에서는 USB 저장장치 접근을 지원하지 않습니다.");
+    return await Promise.resolve({ data: null });
+  }
+}

package/tsconfig.json

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