rnww-plugin-wifi 1.0.0

package/lib/bridge/background-bridge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Background 브릿지 핸들러
+ * 의존성 주입을 통해 동작하는 순수한 브릿지 로직
+ */
+import type { IBridge, IPlatform } from '../types';
+/**
+ * Background 브릿지 설정
+ */
+export interface BackgroundBridgeConfig {
+    bridge: IBridge;
+    platform: IPlatform;
+    logger?: {
+        log: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+}
+/**
+ * Background 브릿지 핸들러를 등록합니다
+ */
+export declare const registerBackgroundHandlers: (config: BackgroundBridgeConfig) => void;
+//# sourceMappingURL=background-bridge.d.ts.map

package/lib/bridge/background-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/background-bridge.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAenD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,CAAC,EAAE;QACP,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;QAClC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;QACnC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;KACrC,CAAC;CACH;AAkHD;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,QAAQ,sBAAsB,KAAG,IAmZ3E,CAAC"}

package/lib/bridge/background-bridge.js

@@ -0,0 +1,493 @@
+"use strict";
+/**
+ * Background 브릿지 핸들러
+ * 의존성 주입을 통해 동작하는 순수한 브릿지 로직
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBackgroundHandlers = void 0;
+const Background = __importStar(require("../modules"));
+/**
+ * 액션 콜백 키 생성
+ */
+function actionCallbackKey(taskId, actionId) {
+    return `${taskId}:${actionId}`;
+}
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+/**
+ * taskId 유효성 검사
+ */
+function isValidTaskId(taskId) {
+    return typeof taskId === 'string' && taskId.trim().length > 0;
+}
+/**
+ * BackgroundTask 기본 유효성 검사
+ */
+function isValidBackgroundTask(task) {
+    if (!task || typeof task !== 'object')
+        return false;
+    const t = task;
+    return (isValidTaskId(t.taskId) &&
+        (t.mode === 'persistent' || t.mode === 'efficient'));
+}
+/**
+ * NotificationConfig 유효성 검사
+ */
+function isValidNotificationConfig(config) {
+    if (!config || typeof config !== 'object')
+        return false;
+    const c = config;
+    return (typeof c.title === 'string' &&
+        typeof c.body === 'string');
+}
+/**
+ * hex color 유효성 검사
+ */
+function isValidHexColor(color) {
+    if (typeof color !== 'string')
+        return false;
+    return /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(color);
+}
+/**
+ * NotificationConfig에서 콜백 함수 추출 및 정규화
+ */
+function extractAndSanitizeNotification(config, taskId, actionCallbackMap) {
+    const sanitized = { ...config };
+    // color 검증
+    if (sanitized.color && !isValidHexColor(sanitized.color)) {
+        delete sanitized.color;
+    }
+    // actions 처리
+    if (sanitized.actions && sanitized.actions.length > 0) {
+        // 최대 3개 제한
+        const limitedActions = sanitized.actions.slice(0, 3);
+        // 각 액션에서 onPress 콜백 추출 및 저장
+        sanitized.actions = limitedActions.map((action) => {
+            if (action.onPress && typeof action.onPress === 'function') {
+                // 콜백 저장
+                actionCallbackMap.set(actionCallbackKey(taskId, action.id), action.onPress);
+            }
+            // 네이티브에 전달할 때는 onPress 제외
+            const { onPress, ...actionWithoutCallback } = action;
+            return actionWithoutCallback;
+        });
+    }
+    // progress 값 검증
+    if (sanitized.progress) {
+        sanitized.progress = {
+            ...sanitized.progress,
+            current: Math.max(0, sanitized.progress.current),
+            max: Math.max(1, sanitized.progress.max),
+        };
+        if (sanitized.progress.current > sanitized.progress.max) {
+            sanitized.progress.current = sanitized.progress.max;
+        }
+    }
+    return sanitized;
+}
+// ============================================================================
+// Main Handler
+// ============================================================================
+/** 중복 등록 방지 플래그 */
+let isRegistered = false;
+/**
+ * Background 브릿지 핸들러를 등록합니다
+ */
+const registerBackgroundHandlers = (config) => {
+    const { bridge, platform, logger = console } = config;
+    // 플랫폼 체크
+    if (platform.OS !== 'android' && platform.OS !== 'ios') {
+        logger.log('[Bridge] Background handlers skipped (Android/iOS only)');
+        return;
+    }
+    // 중복 등록 방지
+    if (isRegistered) {
+        logger.warn('[Bridge] Background handlers already registered, skipping');
+        return;
+    }
+    isRegistered = true;
+    // 이벤트 리스너 구독 객체
+    let eventSubscription = null;
+    // 작업별 콜백 ID 매핑 (taskId → callbackId)
+    const callbackIdMap = new Map();
+    // 작업 콜백 함수 저장소 (taskId → callback)
+    const taskCallbackMap = new Map();
+    // 액션 콜백 함수 저장소 (taskId:actionId → callback)
+    const actionCallbackMap = new Map();
+    /**
+     * 이벤트 핸들러 - 콜백 실행 및 Web 전달
+     */
+    const handleTaskEvent = (event) => {
+        // 이벤트 검증
+        if (!event || !isValidTaskId(event.taskId)) {
+            logger.warn('[Bridge] Invalid task event received:', event);
+            return;
+        }
+        // callbackId 추가
+        const enrichedEvent = {
+            ...event,
+            callbackId: callbackIdMap.get(event.taskId),
+        };
+        // 액션 이벤트인 경우 액션 콜백 우선 실행
+        if (event.type === 'action' && event.actionId) {
+            const actionCallback = actionCallbackMap.get(actionCallbackKey(event.taskId, event.actionId));
+            if (actionCallback) {
+                Promise.resolve()
+                    .then(() => actionCallback(event.actionId, event.taskId))
+                    .catch((error) => {
+                    logger.error('[Bridge] Action callback error:', error);
+                });
+            }
+        }
+        // Web으로 이벤트 전달 (non-blocking)
+        try {
+            bridge.sendToWeb('onTaskEvent', enrichedEvent);
+        }
+        catch (error) {
+            logger.error('[Bridge] Failed to send event to web:', error);
+        }
+        // 작업 콜백 실행 (비동기, non-blocking)
+        const taskCallback = taskCallbackMap.get(event.taskId);
+        if (taskCallback) {
+            Promise.resolve()
+                .then(() => taskCallback(enrichedEvent))
+                .catch((error) => {
+                logger.error('[Bridge] Task callback error:', error);
+            });
+        }
+    };
+    /**
+     * 이벤트 리스너 초기화
+     */
+    const ensureEventListener = () => {
+        if (!eventSubscription) {
+            eventSubscription = Background.addTaskEventListener(handleTaskEvent);
+        }
+    };
+    /**
+     * 특정 작업의 액션 콜백 정리
+     */
+    const clearActionCallbacks = (taskId) => {
+        const keysToDelete = [];
+        actionCallbackMap.forEach((_, key) => {
+            if (key.startsWith(`${taskId}:`)) {
+                keysToDelete.push(key);
+            }
+        });
+        keysToDelete.forEach((key) => actionCallbackMap.delete(key));
+    };
+    // ============================================================================
+    // Handler Registration
+    // ============================================================================
+    // 작업 등록
+    bridge.registerHandler('registerTask', async (payload, respond) => {
+        try {
+            // 입력 검증
+            if (!isValidBackgroundTask(payload)) {
+                respond({
+                    success: false,
+                    error: 'INVALID_INPUT',
+                    message: 'Invalid task configuration: taskId and mode are required',
+                });
+                return;
+            }
+            const task = payload;
+            const { callback, notification, ...taskConfig } = task;
+            // notification 정규화 및 액션 콜백 추출
+            const sanitizedNotification = notification
+                ? extractAndSanitizeNotification(notification, task.taskId, actionCallbackMap)
+                : undefined;
+            const sanitizedTask = {
+                ...taskConfig,
+                ...(sanitizedNotification && { notification: sanitizedNotification }),
+            };
+            // 네이티브 모듈에 등록
+            const result = await Background.registerTask(sanitizedTask);
+            // 등록 성공 시에만 콜백 저장
+            if (result.success) {
+                if (task.callbackId) {
+                    callbackIdMap.set(task.taskId, task.callbackId);
+                }
+                if (callback && typeof callback === 'function') {
+                    taskCallbackMap.set(task.taskId, callback);
+                }
+            }
+            else {
+                // 실패 시 저장된 액션 콜백 정리
+                clearActionCallbacks(task.taskId);
+            }
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] registerTask error:', error);
+            respond({
+                success: false,
+                error: 'UNKNOWN',
+                message: error instanceof Error ? error.message : 'Failed to register task',
+            });
+        }
+    });
+    // 작업 해제
+    bridge.registerHandler('unregisterTask', async (payload, respond) => {
+        try {
+            const data = payload;
+            const taskId = data?.taskId;
+            // 입력 검증
+            if (!isValidTaskId(taskId)) {
+                respond({
+                    success: false,
+                    error: 'INVALID_INPUT',
+                    message: 'Invalid taskId',
+                });
+                return;
+            }
+            // 모든 콜백 정리
+            callbackIdMap.delete(taskId);
+            taskCallbackMap.delete(taskId);
+            clearActionCallbacks(taskId);
+            const result = await Background.unregisterTask(taskId);
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] unregisterTask error:', error);
+            respond({
+                success: false,
+                error: 'UNKNOWN',
+                message: error instanceof Error ? error.message : 'Failed to unregister task',
+            });
+        }
+    });
+    // 작업 시작
+    bridge.registerHandler('startTask', async (payload, respond) => {
+        try {
+            const data = payload;
+            const taskId = data?.taskId;
+            // 입력 검증
+            if (!isValidTaskId(taskId)) {
+                respond({
+                    success: false,
+                    error: 'INVALID_INPUT',
+                    message: 'Invalid taskId',
+                });
+                return;
+            }
+            ensureEventListener();
+            const result = await Background.startTask(taskId);
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] startTask error:', error);
+            respond({
+                success: false,
+                error: 'UNKNOWN',
+                message: error instanceof Error ? error.message : 'Failed to start task',
+            });
+        }
+    });
+    // 작업 중지
+    bridge.registerHandler('stopTask', async (payload, respond) => {
+        try {
+            const data = payload;
+            const taskId = data?.taskId;
+            // 입력 검증
+            if (!isValidTaskId(taskId)) {
+                respond({
+                    success: false,
+                    error: 'INVALID_INPUT',
+                    message: 'Invalid taskId',
+                });
+                return;
+            }
+            const result = await Background.stopTask(taskId);
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] stopTask error:', error);
+            respond({
+                success: false,
+                error: 'UNKNOWN',
+                message: error instanceof Error ? error.message : 'Failed to stop task',
+            });
+        }
+    });
+    // 모든 작업 중지
+    bridge.registerHandler('stopAllTasks', async (_payload, respond) => {
+        try {
+            const result = await Background.stopAllTasks();
+            // 이벤트 리스너 해제
+            if (eventSubscription) {
+                eventSubscription.remove();
+                eventSubscription = null;
+            }
+            // 모든 콜백 정리
+            callbackIdMap.clear();
+            taskCallbackMap.clear();
+            actionCallbackMap.clear();
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] stopAllTasks error:', error);
+            respond({
+                success: false,
+                error: 'UNKNOWN',
+                message: error instanceof Error ? error.message : 'Failed to stop all tasks',
+            });
+        }
+    });
+    // 알림 업데이트 (액션 콜백 지원)
+    bridge.registerHandler('updateNotification', async (payload, respond) => {
+        try {
+            // 입력 검증
+            if (!isValidNotificationConfig(payload)) {
+                respond({
+                    success: false,
+                    error: 'Invalid notification config: title and body are required',
+                });
+                return;
+            }
+            const config = payload;
+            const taskId = config.taskId || 'default';
+            // 기존 액션 콜백 정리 후 새로 등록
+            if (config.actions) {
+                clearActionCallbacks(taskId);
+            }
+            const sanitizedConfig = extractAndSanitizeNotification(config, taskId, actionCallbackMap);
+            const result = await Background.updateNotification(sanitizedConfig);
+            respond(result);
+        }
+        catch (error) {
+            logger.error('[Bridge] updateNotification error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to update notification',
+            });
+        }
+    });
+    // 특정 작업 상태 조회
+    bridge.registerHandler('getTaskStatus', async (payload, respond) => {
+        try {
+            const data = payload;
+            const taskId = data?.taskId;
+            // 입력 검증
+            if (!isValidTaskId(taskId)) {
+                respond({
+                    success: false,
+                    error: 'Invalid taskId',
+                });
+                return;
+            }
+            const status = await Background.getTaskStatus(taskId);
+            respond({ success: true, status });
+        }
+        catch (error) {
+            logger.error('[Bridge] getTaskStatus error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get task status',
+            });
+        }
+    });
+    // 전체 작업 상태 조회
+    bridge.registerHandler('getAllTasksStatus', async (_payload, respond) => {
+        try {
+            const status = await Background.getAllTasksStatus();
+            respond({ success: true, ...status });
+        }
+        catch (error) {
+            logger.error('[Bridge] getAllTasksStatus error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to get all tasks status',
+            });
+        }
+    });
+    // 권한 확인
+    bridge.registerHandler('checkBackgroundPermission', async (_payload, respond) => {
+        try {
+            const status = await Background.checkBackgroundPermission();
+            respond({ success: true, ...status });
+        }
+        catch (error) {
+            logger.error('[Bridge] checkBackgroundPermission error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to check permission',
+            });
+        }
+    });
+    // 권한 요청
+    bridge.registerHandler('requestBackgroundPermission', async (_payload, respond) => {
+        try {
+            const status = await Background.requestBackgroundPermission();
+            respond({ success: true, ...status });
+        }
+        catch (error) {
+            logger.error('[Bridge] requestBackgroundPermission error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to request permission',
+            });
+        }
+    });
+    // 리소스 정리 (dispose)
+    bridge.registerHandler('disposeBackgroundHandlers', async (_payload, respond) => {
+        try {
+            // 이벤트 리스너 해제
+            if (eventSubscription) {
+                eventSubscription.remove();
+                eventSubscription = null;
+            }
+            // 모든 콜백 정리
+            callbackIdMap.clear();
+            taskCallbackMap.clear();
+            actionCallbackMap.clear();
+            // 재등록 가능하도록 플래그 리셋
+            isRegistered = false;
+            logger.log('[Bridge] Background handlers disposed');
+            respond({ success: true });
+        }
+        catch (error) {
+            logger.error('[Bridge] disposeBackgroundHandlers error:', error);
+            respond({
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to dispose handlers',
+            });
+        }
+    });
+    logger.log('[Bridge] Background handlers registered');
+};
+exports.registerBackgroundHandlers = registerBackgroundHandlers;

package/lib/bridge/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WiFi Bridge Main Entry Point
+ */
+export { registerWifiHandlers } from './wifi-bridge';
+export * from '../types';
+//# sourceMappingURL=index.d.ts.map

package/lib/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bridge/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAErD,cAAc,UAAU,CAAC"}

package/lib/bridge/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * WiFi Bridge Main Entry Point
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWifiHandlers = void 0;
+var wifi_bridge_1 = require("./wifi-bridge");
+Object.defineProperty(exports, "registerWifiHandlers", { enumerable: true, get: function () { return wifi_bridge_1.registerWifiHandlers; } });
+__exportStar(require("../types"), exports);

package/lib/bridge/wifi-bridge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * WiFi Bridge Handlers
+ * WebView에서 호출 가능한 WiFi 관련 핸들러 등록
+ */
+import type { IBridge, IPlatform } from '../types';
+interface WifiBridgeConfig {
+    bridge: IBridge;
+    platform: IPlatform;
+}
+/**
+ * WiFi 브릿지 핸들러 등록
+ * @param config 브릿지 설정 (bridge 인스턴스, platform 정보)
+ */
+export declare function registerWifiHandlers(config: WifiBridgeConfig): void;
+export {};
+//# sourceMappingURL=wifi-bridge.d.ts.map

package/lib/bridge/wifi-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wifi-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/wifi-bridge.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAoC,MAAM,UAAU,CAAC;AAGrF,UAAU,gBAAgB;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAuKnE"}