rnww-plugin-wifi 1.0.0

package/src/modules/index.ts

@@ -0,0 +1,166 @@
+/**
+ * WiFi Module (Cross-Platform)
+ * WiFi 정보 조회 및 연결 관리 기능 제공
+ * Supports: Android, iOS
+ */
+
+import { requireNativeModule } from 'expo-modules-core';
+import { Platform } from 'react-native';
+import type {
+  WifiInfoResult,
+  WifiListResult,
+  WifiStateResult,
+  ConnectOptions,
+  ConnectResult,
+  WifiResult,
+  PermissionStatus,
+  WifiStateChangeEvent,
+} from '../types/wifi-module';
+
+// Lazy 모듈 로드 (크래시 방지)
+let WifiModule: any = null;
+
+function getWifiModule() {
+  if (Platform.OS !== 'android' && Platform.OS !== 'ios') {
+    return null;
+  }
+
+  if (WifiModule === null) {
+    try {
+      WifiModule = requireNativeModule('CustomWifi');
+    } catch (error) {
+      console.error('[CustomWifi] Failed to load native module:', error);
+      WifiModule = undefined;
+      return null;
+    }
+  }
+
+  return WifiModule === undefined ? null : WifiModule;
+}
+
+/**
+ * 현재 연결된 WiFi 정보 조회
+ */
+export async function getCurrentWifiInfo(): Promise<WifiInfoResult> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      success: false,
+      error: 'Module not available',
+      errorCode: 'MODULE_NOT_AVAILABLE',
+    };
+  }
+  return await module.getCurrentWifiInfo();
+}
+
+/**
+ * 사용 가능한 WiFi 목록 스캔 (Android only)
+ */
+export async function getWifiList(): Promise<WifiListResult> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      success: false,
+      error: 'Module not available',
+      errorCode: 'MODULE_NOT_AVAILABLE',
+    };
+  }
+
+  if (Platform.OS === 'ios') {
+    return {
+      success: false,
+      error: 'WiFi scanning is not supported on iOS',
+      errorCode: 'NOT_SUPPORTED',
+    };
+  }
+
+  return await module.getWifiList();
+}
+
+/**
+ * WiFi 활성화 상태 확인
+ */
+export async function isWifiEnabled(): Promise<WifiStateResult> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      success: false,
+      error: 'Module not available',
+      errorCode: 'MODULE_NOT_AVAILABLE',
+    };
+  }
+  return await module.isWifiEnabled();
+}
+
+/**
+ * WiFi 네트워크에 연결
+ */
+export async function connectToWifi(options: ConnectOptions): Promise<ConnectResult> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      success: false,
+      error: 'Module not available',
+      errorCode: 'MODULE_NOT_AVAILABLE',
+    };
+  }
+  return await module.connectToWifi(options);
+}
+
+/**
+ * WiFi 연결 해제
+ */
+export async function disconnect(): Promise<WifiResult> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      success: false,
+      error: 'Module not available',
+      errorCode: 'MODULE_NOT_AVAILABLE',
+    };
+  }
+  return await module.disconnect();
+}
+
+/**
+ * WiFi 권한 확인
+ */
+export async function checkPermission(): Promise<PermissionStatus> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      locationGranted: false,
+      canAccessWifiInfo: false,
+      requiredPermissions: [],
+    };
+  }
+  return await module.checkPermission();
+}
+
+/**
+ * WiFi 권한 요청
+ */
+export async function requestPermission(): Promise<PermissionStatus> {
+  const module = getWifiModule();
+  if (!module) {
+    return {
+      locationGranted: false,
+      canAccessWifiInfo: false,
+      requiredPermissions: [],
+    };
+  }
+  return await module.requestPermission();
+}
+
+/**
+ * WiFi 상태 변경 이벤트 리스너 등록
+ */
+export function addWifiStateListener(
+  listener: (event: WifiStateChangeEvent) => void
+): { remove: () => void } {
+  const module = getWifiModule();
+  if (!module || !module.addListener) {
+    return { remove: () => {} };
+  }
+  return module.addListener('onWifiStateChange', listener);
+}

package/src/modules/ios/WifiModule.swift

@@ -0,0 +1,399 @@
+import ExpoModulesCore
+import UIKit
+import NetworkExtension
+import SystemConfiguration.CaptiveNetwork
+import CoreLocation
+
+public class WifiModule: Module {
+    private var locationManager: CLLocationManager?
+    private var permissionPromise: Promise?
+    private var connectPromise: Promise?
+    private var foregroundObserver: NSObjectProtocol?
+    private var reachabilityObserver: NSObjectProtocol?
+
+    public func definition() -> ModuleDefinition {
+        Name("CustomWifi")
+
+        Events("onWifiStateChange")
+
+        OnCreate {
+            self.setupLocationManager()
+            self.setupReachabilityObserver()
+        }
+
+        OnDestroy {
+            self.cleanup()
+        }
+
+        // 현재 WiFi 정보 조회
+        AsyncFunction("getCurrentWifiInfo") { (promise: Promise) in
+            self.getCurrentWifiInfo(promise: promise)
+        }
+
+        // WiFi 목록 스캔 (iOS에서는 지원되지 않음)
+        AsyncFunction("getWifiList") { (promise: Promise) in
+            promise.resolve([
+                "success": false,
+                "error": "WiFi scanning is not supported on iOS",
+                "errorCode": "NOT_SUPPORTED"
+            ])
+        }
+
+        // WiFi 활성화 상태 확인
+        AsyncFunction("isWifiEnabled") { (promise: Promise) in
+            let isEnabled = self.isWifiEnabled()
+            promise.resolve([
+                "success": true,
+                "isEnabled": isEnabled,
+                "wifiState": isEnabled ? "ENABLED" : "UNKNOWN"
+            ])
+        }
+
+        // WiFi 연결 (iOS 11+)
+        AsyncFunction("connectToWifi") { (options: [String: Any], promise: Promise) in
+            self.connectToWifi(options: options, promise: promise)
+        }
+
+        // WiFi 연결 해제
+        AsyncFunction("disconnect") { (promise: Promise) in
+            self.disconnect(promise: promise)
+        }
+
+        // 권한 확인
+        AsyncFunction("checkPermission") { (promise: Promise) in
+            self.checkPermission(promise: promise)
+        }
+
+        // 권한 요청
+        AsyncFunction("requestPermission") { (promise: Promise) in
+            self.requestPermission(promise: promise)
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func setupLocationManager() {
+        locationManager = CLLocationManager()
+        locationManager?.delegate = LocationDelegate(module: self)
+    }
+
+    private func setupReachabilityObserver() {
+        // 네트워크 상태 변경 감지
+        reachabilityObserver = NotificationCenter.default.addObserver(
+            forName: NSNotification.Name(rawValue: "kNetworkReachabilityChangedNotification"),
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.notifyWifiStateChange()
+        }
+    }
+
+    private func cleanup() {
+        if let observer = foregroundObserver {
+            NotificationCenter.default.removeObserver(observer)
+            foregroundObserver = nil
+        }
+        if let observer = reachabilityObserver {
+            NotificationCenter.default.removeObserver(observer)
+            reachabilityObserver = nil
+        }
+        locationManager = nil
+    }
+
+    private func getCurrentWifiInfo(promise: Promise) {
+        // 위치 권한 확인
+        let status = CLLocationManager.authorizationStatus()
+        guard status == .authorizedWhenInUse || status == .authorizedAlways else {
+            promise.resolve([
+                "success": false,
+                "error": "Location permission required for WiFi info",
+                "errorCode": "PERMISSION_DENIED"
+            ])
+            return
+        }
+
+        let wifiInfo = getWifiInfo()
+        promise.resolve([
+            "success": true,
+            "data": wifiInfo
+        ])
+    }
+
+    private func getWifiInfo() -> [String: Any?] {
+        var ssid: String? = nil
+        var bssid: String? = nil
+
+        // CNCopyCurrentNetworkInfo를 사용하여 SSID 및 BSSID 가져오기
+        if let interfaces = CNCopySupportedInterfaces() as? [String] {
+            for interface in interfaces {
+                if let networkInfo = CNCopyCurrentNetworkInfo(interface as CFString) as? [String: Any] {
+                    ssid = networkInfo[kCNNetworkInfoKeySSID as String] as? String
+                    bssid = networkInfo[kCNNetworkInfoKeyBSSID as String] as? String
+                    break
+                }
+            }
+        }
+
+        let isConnected = ssid != nil
+
+        return [
+            "ssid": ssid,
+            "bssid": bssid,
+            "rssi": nil,  // iOS에서는 직접 가져올 수 없음
+            "signalLevel": nil,
+            "frequency": nil,
+            "linkSpeed": nil,
+            "ipAddress": getWiFiIPAddress(),
+            "isConnected": isConnected
+        ]
+    }
+
+    private func getWiFiIPAddress() -> String? {
+        var address: String?
+        var ifaddr: UnsafeMutablePointer<ifaddrs>?
+
+        guard getifaddrs(&ifaddr) == 0 else { return nil }
+        defer { freeifaddrs(ifaddr) }
+
+        var ptr = ifaddr
+        while ptr != nil {
+            defer { ptr = ptr?.pointee.ifa_next }
+
+            let interface = ptr?.pointee
+            let addrFamily = interface?.ifa_addr.pointee.sa_family
+
+            if addrFamily == UInt8(AF_INET) {
+                let name = String(cString: (interface?.ifa_name)!)
+                if name == "en0" { // WiFi interface
+                    var hostname = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+                    getnameinfo(
+                        interface?.ifa_addr,
+                        socklen_t((interface?.ifa_addr.pointee.sa_len)!),
+                        &hostname,
+                        socklen_t(hostname.count),
+                        nil,
+                        socklen_t(0),
+                        NI_NUMERICHOST
+                    )
+                    address = String(cString: hostname)
+                }
+            }
+        }
+        return address
+    }
+
+    private func isWifiEnabled() -> Bool {
+        // iOS에서는 WiFi 상태를 직접 확인할 수 없으므로 연결 여부로 대체
+        let wifiInfo = getWifiInfo()
+        return wifiInfo["ssid"] != nil
+    }
+
+    private func connectToWifi(options: [String: Any], promise: Promise) {
+        guard let ssid = options["ssid"] as? String, !ssid.isEmpty else {
+            promise.resolve([
+                "success": false,
+                "error": "SSID is required",
+                "errorCode": "INVALID_SSID"
+            ])
+            return
+        }
+
+        let password = options["password"] as? String
+        let isHidden = options["isHidden"] as? Bool ?? false
+
+        if #available(iOS 11.0, *) {
+            var hotspotConfig: NEHotspotConfiguration
+
+            if let pwd = password, !pwd.isEmpty {
+                hotspotConfig = NEHotspotConfiguration(ssid: ssid, passphrase: pwd, isWEP: false)
+            } else {
+                hotspotConfig = NEHotspotConfiguration(ssid: ssid)
+            }
+
+            hotspotConfig.joinOnce = false
+
+            if isHidden {
+                hotspotConfig.hidden = true
+            }
+
+            NEHotspotConfigurationManager.shared.apply(hotspotConfig) { [weak self] error in
+                if let error = error as NSError? {
+                    if error.domain == NEHotspotConfigurationErrorDomain {
+                        switch error.code {
+                        case NEHotspotConfigurationError.alreadyAssociated.rawValue:
+                            // 이미 연결된 경우는 성공으로 처리
+                            let wifiInfo = self?.getWifiInfo()
+                            promise.resolve([
+                                "success": true,
+                                "wifiInfo": wifiInfo as Any
+                            ])
+                            return
+                        case NEHotspotConfigurationError.userDenied.rawValue:
+                            promise.resolve([
+                                "success": false,
+                                "error": "User denied connection",
+                                "errorCode": "CONNECTION_FAILED"
+                            ])
+                            return
+                        case NEHotspotConfigurationError.invalidSSID.rawValue:
+                            promise.resolve([
+                                "success": false,
+                                "error": "Invalid SSID",
+                                "errorCode": "INVALID_SSID"
+                            ])
+                            return
+                        case NEHotspotConfigurationError.invalidWPAPassphrase.rawValue:
+                            promise.resolve([
+                                "success": false,
+                                "error": "Invalid password",
+                                "errorCode": "INVALID_PASSWORD"
+                            ])
+                            return
+                        default:
+                            break
+                        }
+                    }
+                    promise.resolve([
+                        "success": false,
+                        "error": error.localizedDescription,
+                        "errorCode": "CONNECTION_FAILED"
+                    ])
+                    return
+                }
+
+                // 연결 성공
+                let wifiInfo = self?.getWifiInfo()
+                promise.resolve([
+                    "success": true,
+                    "wifiInfo": wifiInfo as Any
+                ])
+            }
+        } else {
+            promise.resolve([
+                "success": false,
+                "error": "WiFi connection requires iOS 11 or later",
+                "errorCode": "NOT_SUPPORTED"
+            ])
+        }
+    }
+
+    private func disconnect(promise: Promise) {
+        if #available(iOS 11.0, *) {
+            // 현재 연결된 SSID 가져오기
+            let wifiInfo = getWifiInfo()
+            if let ssid = wifiInfo["ssid"] as? String {
+                NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: ssid)
+            }
+            promise.resolve(["success": true])
+        } else {
+            promise.resolve([
+                "success": false,
+                "error": "WiFi management requires iOS 11 or later",
+                "errorCode": "NOT_SUPPORTED"
+            ])
+        }
+    }
+
+    private func checkPermission(promise: Promise) {
+        let status = CLLocationManager.authorizationStatus()
+        let locationGranted = status == .authorizedWhenInUse || status == .authorizedAlways
+
+        var requiredPermissions: [String] = []
+        if !locationGranted {
+            requiredPermissions.append("Location (When In Use)")
+        }
+
+        promise.resolve([
+            "locationGranted": locationGranted,
+            "canAccessWifiInfo": locationGranted,
+            "requiredPermissions": requiredPermissions,
+            "details": [
+                "fineLocation": locationGranted,
+                "coarseLocation": status == .authorizedAlways
+            ]
+        ])
+    }
+
+    private func requestPermission(promise: Promise) {
+        let status = CLLocationManager.authorizationStatus()
+
+        if status == .authorizedWhenInUse || status == .authorizedAlways {
+            self.checkPermission(promise: promise)
+            return
+        }
+
+        if status == .notDetermined {
+            // 권한 요청
+            permissionPromise = promise
+            locationManager?.requestWhenInUseAuthorization()
+        } else if status == .denied || status == .restricted {
+            // 설정으로 안내
+            if let observer = foregroundObserver {
+                NotificationCenter.default.removeObserver(observer)
+                foregroundObserver = nil
+            }
+
+            guard let url = URL(string: UIApplication.openSettingsURLString) else {
+                self.checkPermission(promise: promise)
+                return
+            }
+
+            // 앱이 포그라운드로 돌아올 때 상태 확인
+            foregroundObserver = NotificationCenter.default.addObserver(
+                forName: UIApplication.willEnterForegroundNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                if let observer = self?.foregroundObserver {
+                    NotificationCenter.default.removeObserver(observer)
+                    self?.foregroundObserver = nil
+                }
+
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                    self?.checkPermission(promise: promise)
+                }
+            }
+
+            DispatchQueue.main.async {
+                UIApplication.shared.open(url)
+            }
+        }
+    }
+
+    func handlePermissionResult() {
+        if let promise = permissionPromise {
+            checkPermission(promise: promise)
+            permissionPromise = nil
+        }
+    }
+
+    private func notifyWifiStateChange() {
+        let wifiInfo = getWifiInfo()
+        let connectionState = (wifiInfo["isConnected"] as? Bool ?? false) ? "CONNECTED" : "DISCONNECTED"
+
+        sendEvent("onWifiStateChange", [
+            "type": "CONNECTION_STATE_CHANGED",
+            "connectionState": connectionState,
+            "wifiInfo": wifiInfo,
+            "timestamp": Int64(Date().timeIntervalSince1970 * 1000)
+        ])
+    }
+}
+
+// MARK: - Location Delegate
+private class LocationDelegate: NSObject, CLLocationManagerDelegate {
+    weak var module: WifiModule?
+
+    init(module: WifiModule) {
+        self.module = module
+    }
+
+    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+        module?.handlePermissionResult()
+    }
+
+    @available(iOS 14.0, *)
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        module?.handlePermissionResult()
+    }
+}