rnww-plugin-wifi 1.0.0

package/src/modules/android/src/main/java/expo/modules/customwifi/WifiModule.kt

@@ -0,0 +1,517 @@
+package expo.modules.customwifi
+
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.net.wifi.ScanResult
+import android.net.wifi.WifiConfiguration
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import android.net.wifi.WifiNetworkSpecifier
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.exception.Exceptions
+
+class WifiModule : Module() {
+    companion object {
+        private const val TAG = "CustomWifi"
+        private const val EVENT_WIFI_STATE_CHANGE = "onWifiStateChange"
+    }
+
+    private val context: Context
+        get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+    private val wifiManager: WifiManager
+        get() = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
+
+    private val connectivityManager: ConnectivityManager
+        get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+    private var wifiStateReceiver: BroadcastReceiver? = null
+    private var networkCallback: ConnectivityManager.NetworkCallback? = null
+
+    override fun definition() = ModuleDefinition {
+        Name("CustomWifi")
+
+        Events(EVENT_WIFI_STATE_CHANGE)
+
+        OnCreate {
+            registerWifiStateReceiver()
+        }
+
+        OnDestroy {
+            unregisterWifiStateReceiver()
+        }
+
+        // 현재 WiFi 정보 조회
+        AsyncFunction("getCurrentWifiInfo") { promise: Promise ->
+            try {
+                if (!hasLocationPermission()) {
+                    promise.resolve(mapOf(
+                        "success" to false,
+                        "error" to "Location permission required for WiFi info",
+                        "errorCode" to "PERMISSION_DENIED"
+                    ))
+                    return@AsyncFunction
+                }
+
+                val wifiInfo = getWifiInfo()
+                promise.resolve(mapOf(
+                    "success" to true,
+                    "data" to wifiInfo
+                ))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error getting WiFi info", e)
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to (e.message ?: "Unknown error"),
+                    "errorCode" to "UNKNOWN"
+                ))
+            }
+        }
+
+        // WiFi 목록 스캔
+        AsyncFunction("getWifiList") { promise: Promise ->
+            try {
+                if (!hasLocationPermission()) {
+                    promise.resolve(mapOf(
+                        "success" to false,
+                        "error" to "Location permission required for WiFi scanning",
+                        "errorCode" to "PERMISSION_DENIED"
+                    ))
+                    return@AsyncFunction
+                }
+
+                if (!wifiManager.isWifiEnabled) {
+                    promise.resolve(mapOf(
+                        "success" to false,
+                        "error" to "WiFi is disabled",
+                        "errorCode" to "WIFI_DISABLED"
+                    ))
+                    return@AsyncFunction
+                }
+
+                wifiManager.startScan()
+                val scanResults = wifiManager.scanResults
+                val networks = scanResults.map { result ->
+                    mapOf(
+                        "ssid" to result.SSID,
+                        "bssid" to result.BSSID,
+                        "rssi" to result.level,
+                        "signalLevel" to WifiManager.calculateSignalLevel(result.level, 100),
+                        "frequency" to result.frequency,
+                        "security" to getSecurityType(result),
+                        "channel" to frequencyToChannel(result.frequency)
+                    )
+                }.filter { it["ssid"] != "" }
+
+                promise.resolve(mapOf(
+                    "success" to true,
+                    "data" to networks
+                ))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error scanning WiFi", e)
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to (e.message ?: "Unknown error"),
+                    "errorCode" to "UNKNOWN"
+                ))
+            }
+        }
+
+        // WiFi 활성화 상태 확인
+        AsyncFunction("isWifiEnabled") { promise: Promise ->
+            try {
+                val isEnabled = wifiManager.isWifiEnabled
+                val wifiState = when (wifiManager.wifiState) {
+                    WifiManager.WIFI_STATE_DISABLED -> "DISABLED"
+                    WifiManager.WIFI_STATE_DISABLING -> "DISABLING"
+                    WifiManager.WIFI_STATE_ENABLED -> "ENABLED"
+                    WifiManager.WIFI_STATE_ENABLING -> "ENABLING"
+                    else -> "UNKNOWN"
+                }
+
+                promise.resolve(mapOf(
+                    "success" to true,
+                    "isEnabled" to isEnabled,
+                    "wifiState" to wifiState
+                ))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error checking WiFi state", e)
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to (e.message ?: "Unknown error"),
+                    "errorCode" to "UNKNOWN"
+                ))
+            }
+        }
+
+        // WiFi 연결
+        AsyncFunction("connectToWifi") { options: Map<String, Any?>, promise: Promise ->
+            try {
+                val ssid = options["ssid"] as? String
+                if (ssid.isNullOrEmpty()) {
+                    promise.resolve(mapOf(
+                        "success" to false,
+                        "error" to "SSID is required",
+                        "errorCode" to "INVALID_SSID"
+                    ))
+                    return@AsyncFunction
+                }
+
+                val password = options["password"] as? String
+                val isHidden = options["isHidden"] as? Boolean ?: false
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    // Android 10+ uses WifiNetworkSpecifier
+                    connectWifiAndroid10(ssid, password, isHidden, promise)
+                } else {
+                    // Legacy connection method
+                    connectWifiLegacy(ssid, password, isHidden, promise)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error connecting to WiFi", e)
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to (e.message ?: "Unknown error"),
+                    "errorCode" to "CONNECTION_FAILED"
+                ))
+            }
+        }
+
+        // WiFi 연결 해제
+        AsyncFunction("disconnect") { promise: Promise ->
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    // Android 10+ - unregister network callback
+                    networkCallback?.let {
+                        connectivityManager.unregisterNetworkCallback(it)
+                        networkCallback = null
+                    }
+                    promise.resolve(mapOf("success" to true))
+                } else {
+                    @Suppress("DEPRECATION")
+                    val result = wifiManager.disconnect()
+                    promise.resolve(mapOf("success" to result))
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error disconnecting WiFi", e)
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to (e.message ?: "Unknown error"),
+                    "errorCode" to "UNKNOWN"
+                ))
+            }
+        }
+
+        // 권한 확인
+        AsyncFunction("checkPermission") { promise: Promise ->
+            try {
+                val fineLocation = ContextCompat.checkSelfPermission(
+                    context, Manifest.permission.ACCESS_FINE_LOCATION
+                ) == PackageManager.PERMISSION_GRANTED
+
+                val coarseLocation = ContextCompat.checkSelfPermission(
+                    context, Manifest.permission.ACCESS_COARSE_LOCATION
+                ) == PackageManager.PERMISSION_GRANTED
+
+                val requiredPermissions = mutableListOf<String>()
+                if (!fineLocation) {
+                    requiredPermissions.add(Manifest.permission.ACCESS_FINE_LOCATION)
+                }
+
+                promise.resolve(mapOf(
+                    "locationGranted" to fineLocation,
+                    "canAccessWifiInfo" to fineLocation,
+                    "requiredPermissions" to requiredPermissions,
+                    "details" to mapOf(
+                        "fineLocation" to fineLocation,
+                        "coarseLocation" to coarseLocation
+                    )
+                ))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error checking permission", e)
+                promise.resolve(mapOf(
+                    "locationGranted" to false,
+                    "canAccessWifiInfo" to false,
+                    "requiredPermissions" to listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+                ))
+            }
+        }
+
+        // 권한 요청
+        AsyncFunction("requestPermission") { promise: Promise ->
+            try {
+                val permissions = appContext.permissions
+                if (permissions == null) {
+                    promise.resolve(mapOf(
+                        "locationGranted" to false,
+                        "canAccessWifiInfo" to false,
+                        "requiredPermissions" to listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+                    ))
+                    return@AsyncFunction
+                }
+
+                permissions.askForPermissions(
+                    { result ->
+                        val granted = result[Manifest.permission.ACCESS_FINE_LOCATION]?.granted ?: false
+                        promise.resolve(mapOf(
+                            "locationGranted" to granted,
+                            "canAccessWifiInfo" to granted,
+                            "requiredPermissions" to if (granted) emptyList<String>()
+                                else listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+                        ))
+                    },
+                    Manifest.permission.ACCESS_FINE_LOCATION
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "Error requesting permission", e)
+                promise.resolve(mapOf(
+                    "locationGranted" to false,
+                    "canAccessWifiInfo" to false,
+                    "requiredPermissions" to listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+                ))
+            }
+        }
+    }
+
+    private fun hasLocationPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context, Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun getWifiInfo(): Map<String, Any?> {
+        @Suppress("DEPRECATION")
+        val wifiInfo: WifiInfo? = wifiManager.connectionInfo
+        val isConnected = isWifiConnected()
+
+        if (wifiInfo == null || !isConnected) {
+            return mapOf(
+                "ssid" to null,
+                "bssid" to null,
+                "rssi" to null,
+                "signalLevel" to null,
+                "frequency" to null,
+                "linkSpeed" to null,
+                "ipAddress" to null,
+                "isConnected" to false
+            )
+        }
+
+        val ssid = wifiInfo.ssid?.replace("\"", "")?.let {
+            if (it == "<unknown ssid>") null else it
+        }
+
+        return mapOf(
+            "ssid" to ssid,
+            "bssid" to wifiInfo.bssid,
+            "rssi" to wifiInfo.rssi,
+            "signalLevel" to WifiManager.calculateSignalLevel(wifiInfo.rssi, 100),
+            "frequency" to wifiInfo.frequency,
+            "linkSpeed" to wifiInfo.linkSpeed,
+            "ipAddress" to intToIp(wifiInfo.ipAddress),
+            "isConnected" to isConnected,
+            "networkId" to wifiInfo.networkId
+        )
+    }
+
+    private fun isWifiConnected(): Boolean {
+        val network = connectivityManager.activeNetwork ?: return false
+        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+    }
+
+    private fun intToIp(ip: Int): String {
+        return "${ip and 0xFF}.${ip shr 8 and 0xFF}.${ip shr 16 and 0xFF}.${ip shr 24 and 0xFF}"
+    }
+
+    private fun getSecurityType(scanResult: ScanResult): String {
+        val capabilities = scanResult.capabilities
+        return when {
+            capabilities.contains("WPA3") -> "WPA3"
+            capabilities.contains("WPA2") && capabilities.contains("WPA3") -> "WPA2_WPA3"
+            capabilities.contains("WPA2") -> "WPA2"
+            capabilities.contains("WPA") && capabilities.contains("WPA2") -> "WPA_WPA2"
+            capabilities.contains("WPA") -> "WPA"
+            capabilities.contains("WEP") -> "WEP"
+            else -> "OPEN"
+        }
+    }
+
+    private fun frequencyToChannel(frequency: Int): Int {
+        return when {
+            frequency in 2412..2484 -> (frequency - 2412) / 5 + 1
+            frequency in 5170..5825 -> (frequency - 5170) / 5 + 34
+            else -> -1
+        }
+    }
+
+    private fun connectWifiAndroid10(ssid: String, password: String?, isHidden: Boolean, promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            promise.resolve(mapOf(
+                "success" to false,
+                "error" to "Android 10+ required",
+                "errorCode" to "NOT_SUPPORTED"
+            ))
+            return
+        }
+
+        val specifierBuilder = WifiNetworkSpecifier.Builder()
+            .setSsid(ssid)
+            .setIsHiddenSsid(isHidden)
+
+        if (!password.isNullOrEmpty()) {
+            specifierBuilder.setWpa2Passphrase(password)
+        }
+
+        val networkRequest = NetworkRequest.Builder()
+            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+            .setNetworkSpecifier(specifierBuilder.build())
+            .build()
+
+        networkCallback = object : ConnectivityManager.NetworkCallback() {
+            override fun onAvailable(network: Network) {
+                super.onAvailable(network)
+                connectivityManager.bindProcessToNetwork(network)
+                val wifiInfo = getWifiInfo()
+                promise.resolve(mapOf(
+                    "success" to true,
+                    "wifiInfo" to wifiInfo
+                ))
+            }
+
+            override fun onUnavailable() {
+                super.onUnavailable()
+                promise.resolve(mapOf(
+                    "success" to false,
+                    "error" to "Network unavailable",
+                    "errorCode" to "CONNECTION_FAILED"
+                ))
+            }
+        }
+
+        connectivityManager.requestNetwork(networkRequest, networkCallback!!)
+    }
+
+    @Suppress("DEPRECATION")
+    private fun connectWifiLegacy(ssid: String, password: String?, isHidden: Boolean, promise: Promise) {
+        val wifiConfig = WifiConfiguration().apply {
+            SSID = "\"$ssid\""
+            hiddenSSID = isHidden
+
+            if (password.isNullOrEmpty()) {
+                allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
+            } else {
+                preSharedKey = "\"$password\""
+                allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
+            }
+        }
+
+        val networkId = wifiManager.addNetwork(wifiConfig)
+        if (networkId == -1) {
+            promise.resolve(mapOf(
+                "success" to false,
+                "error" to "Failed to add network configuration",
+                "errorCode" to "CONNECTION_FAILED"
+            ))
+            return
+        }
+
+        wifiManager.disconnect()
+        val enabled = wifiManager.enableNetwork(networkId, true)
+        val reconnected = wifiManager.reconnect()
+
+        if (enabled && reconnected) {
+            val wifiInfo = getWifiInfo()
+            promise.resolve(mapOf(
+                "success" to true,
+                "wifiInfo" to wifiInfo
+            ))
+        } else {
+            promise.resolve(mapOf(
+                "success" to false,
+                "error" to "Failed to connect to network",
+                "errorCode" to "CONNECTION_FAILED"
+            ))
+        }
+    }
+
+    private fun registerWifiStateReceiver() {
+        if (wifiStateReceiver != null) return
+
+        wifiStateReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                when (intent?.action) {
+                    WifiManager.WIFI_STATE_CHANGED_ACTION -> {
+                        val state = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN)
+                        val wifiState = when (state) {
+                            WifiManager.WIFI_STATE_DISABLED -> "DISABLED"
+                            WifiManager.WIFI_STATE_DISABLING -> "DISABLING"
+                            WifiManager.WIFI_STATE_ENABLED -> "ENABLED"
+                            WifiManager.WIFI_STATE_ENABLING -> "ENABLING"
+                            else -> "UNKNOWN"
+                        }
+
+                        sendEvent(EVENT_WIFI_STATE_CHANGE, mapOf(
+                            "type" to "WIFI_STATE_CHANGED",
+                            "wifiState" to wifiState,
+                            "timestamp" to System.currentTimeMillis()
+                        ))
+                    }
+
+                    WifiManager.NETWORK_STATE_CHANGED_ACTION -> {
+                        val wifiInfo = getWifiInfo()
+                        val connectionState = if (wifiInfo["isConnected"] == true) "CONNECTED" else "DISCONNECTED"
+
+                        sendEvent(EVENT_WIFI_STATE_CHANGE, mapOf(
+                            "type" to "CONNECTION_STATE_CHANGED",
+                            "connectionState" to connectionState,
+                            "wifiInfo" to wifiInfo,
+                            "timestamp" to System.currentTimeMillis()
+                        ))
+                    }
+                }
+            }
+        }
+
+        val intentFilter = IntentFilter().apply {
+            addAction(WifiManager.WIFI_STATE_CHANGED_ACTION)
+            addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION)
+        }
+
+        context.registerReceiver(wifiStateReceiver, intentFilter)
+        Log.d(TAG, "WiFi state receiver registered")
+    }
+
+    private fun unregisterWifiStateReceiver() {
+        wifiStateReceiver?.let {
+            try {
+                context.unregisterReceiver(it)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error unregistering receiver", e)
+            }
+            wifiStateReceiver = null
+        }
+
+        networkCallback?.let {
+            try {
+                connectivityManager.unregisterNetworkCallback(it)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error unregistering network callback", e)
+            }
+            networkCallback = null
+        }
+    }
+}

package/src/modules/android/src/main/java/expo/modules/customwifi/WifiStateReceiver.kt

@@ -0,0 +1,46 @@
+package expo.modules.customwifi
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.net.wifi.WifiManager
+import android.util.Log
+
+/**
+ * WiFi 상태 변경을 감지하는 BroadcastReceiver
+ * AndroidManifest.xml에 등록되어 시스템 레벨에서 WiFi 상태 변경을 수신
+ */
+class WifiStateReceiver : BroadcastReceiver() {
+    companion object {
+        private const val TAG = "WifiStateReceiver"
+    }
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        if (context == null || intent == null) return
+
+        when (intent.action) {
+            WifiManager.WIFI_STATE_CHANGED_ACTION -> {
+                val state = intent.getIntExtra(
+                    WifiManager.EXTRA_WIFI_STATE,
+                    WifiManager.WIFI_STATE_UNKNOWN
+                )
+                val stateName = when (state) {
+                    WifiManager.WIFI_STATE_DISABLED -> "DISABLED"
+                    WifiManager.WIFI_STATE_DISABLING -> "DISABLING"
+                    WifiManager.WIFI_STATE_ENABLED -> "ENABLED"
+                    WifiManager.WIFI_STATE_ENABLING -> "ENABLING"
+                    else -> "UNKNOWN"
+                }
+                Log.d(TAG, "WiFi state changed: $stateName")
+            }
+
+            WifiManager.NETWORK_STATE_CHANGED_ACTION -> {
+                Log.d(TAG, "Network state changed")
+            }
+
+            "android.net.conn.CONNECTIVITY_CHANGE" -> {
+                Log.d(TAG, "Connectivity changed")
+            }
+        }
+    }
+}

package/src/modules/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["android", "ios"],
+  "android": {
+    "modules": ["expo.modules.customwifi.WifiModule"]
+  },
+  "ios": {
+    "modules": ["WifiModule"]
+  }
+}