munim-wifi 0.1.0 → 0.1.2

package/README.md

@@ -79,20 +79,87 @@
 ### Wi-Fi Scanning
 
 - 📡 **Network Scanning**: Scan for nearby Wi-Fi networks with detailed information
-- 📶 **Signal Strength**: Get RSSI (signal strength) values for all networks
-- 🔍 **Network Details**: Retrieve SSIDs, BSSIDs (MAC addresses), channels, and frequencies
+- 📶 **Signal Strength**: Get RSSI (signal strength) values for all networks (Android only)
+- 🔍 **Network Details**: Retrieve SSIDs, BSSIDs (MAC addresses), channels, and frequencies (Android only)
 - 📊 **Wi-Fi Fingerprinting**: Create comprehensive Wi-Fi fingerprints for location services
-- 🔄 **Continuous Scanning**: Support for continuous scanning with event-based updates
+- 🔄 **Continuous Scanning**: Support for continuous scanning with event-based updates (Android only)
 - 📱 **Cross-platform**: Works on both iOS and Android
 
+### Network Management
+
+- 🔌 **Connect to Networks**: Programmatically connect to Wi-Fi networks
+- 🔌 **Disconnect**: Disconnect from current Wi-Fi network
+- 📱 **Current Network Info**: Get information about currently connected network
+- 🌐 **IP Address**: Retrieve IP address information for current connection
+
 ### Additional Features
 
-- 📱 **Cross-platform**: Works on both iOS and Android
+- 📱 **Cross-platform**: Works on both iOS and Android (with platform-specific limitations)
 - 🎯 **TypeScript Support**: Full TypeScript definitions included
 - ⚡ **High Performance**: Built with React Native's Nitro modules architecture
 - 🚀 **Expo Compatible**: Works seamlessly with Expo managed and bare workflows
 - 🔐 **Permission Handling**: Built-in permission request helpers
 
+### ⚠️ Platform Limitations
+
+#### iOS Limitations
+
+**Critical: CoreWLAN is macOS Only**
+CoreWLAN framework is NOT available on iOS - it only works on macOS. The iOS implementation uses `NEHotspotNetwork` and `NEHotspotConfiguration` APIs.
+
+**iOS Wi-Fi Scanning Capabilities:**
+iOS has very limited Wi-Fi scanning capabilities:
+
+✅ **Available on iOS:**
+- Get SSID (network name) - via `NEHotspotNetwork.fetchCurrent()`
+- Get BSSID (MAC address) - via `NEHotspotNetwork.fetchCurrent()`
+- Connect to Wi-Fi networks - via `NEHotspotConfiguration`
+- Disconnect from Wi-Fi - via `NEHotspotConfiguration`
+- Get current connected network info
+
+❌ **NOT Available on iOS:**
+- RSSI (signal strength) - Cannot be retrieved for scanned networks
+- Channel information - Not available
+- Frequency information - Not available
+- General network scanning - Only works for hotspot networks via NEHotspotHelper (requires special entitlement)
+
+**iOS Requirements:**
+- Location permission (precise location) required
+- "Access Wi-Fi Information" entitlement in Xcode
+- "Hotspot Configuration" capability for connecting to networks
+- iOS 13+ requires location permission
+
+#### Android Limitations
+
+**Scanning Restrictions:**
+- `WifiManager.startScan()` is deprecated in Android P (API 28) but still works
+- **Throttling limits:**
+  - Foreground apps: 4 scans every 2 minutes
+  - Background apps: More restrictive
+- Requires location permission (Android 6.0+)
+- Passive listening available on Android 10+ (API 29)
+
+✅ **Available on Android:**
+- Full network scanning with SSID, BSSID, RSSI, channel, frequency
+- Connect/disconnect to networks
+- Get current network info
+- All features work, but with throttling limits
+
+#### Feature Support Matrix
+
+| Feature | iOS | Android | Notes |
+|---------|-----|---------|-------|
+| Scan networks | ⚠️ Limited | ✅ Full | iOS: SSID/BSSID only, no RSSI/channel/frequency |
+| Get SSID | ✅ | ✅ | Both platforms |
+| Get BSSID | ✅ | ✅ | Both platforms |
+| Get RSSI | ❌ | ✅ | iOS: Not available for scanned networks |
+| Get Channel | ❌ | ✅ | iOS: Not available |
+| Get Frequency | ❌ | ✅ | iOS: Not available |
+| Connect to network | ✅ | ✅ | Both platforms (requires entitlements/capabilities) |
+| Disconnect | ✅ | ✅ | Both platforms |
+| Get current network | ✅ | ✅ | Both platforms |
+| Wi-Fi fingerprinting | ⚠️ Limited | ✅ Full | iOS: Limited to SSID/BSSID only |
+
 ## 📦 Installation
 
 ### React Native CLI
@@ -344,16 +411,18 @@ Gets BSSID (MAC address) for a specific network by SSID.
 #### `getChannelInfo(ssid)`
 
 Gets channel and frequency information for a specific network by SSID.
+**Note: Not available on iOS - returns null.**
 
 **Parameters:**
 
 - `ssid` (string): The SSID of the network
 
-**Returns:** Promise<{ channel: number; frequency: number } | null>
+**Returns:** Promise<ChannelInfo | null>
 
 #### `getNetworkInfo(ssid)`
 
 Gets all available information for a specific network by SSID.
+**Note: On iOS, RSSI, channel, and frequency will be undefined.**
 
 **Parameters:**
 
@@ -361,6 +430,38 @@ Gets all available information for a specific network by SSID.
 
 **Returns:** Promise<WifiNetwork | null>
 
+#### `getCurrentNetwork()`
+
+Gets information about the currently connected Wi-Fi network.
+
+**Returns:** Promise<CurrentNetworkInfo | null>
+
+#### `connectToNetwork(options)`
+
+Connects to a Wi-Fi network.
+**Note: Requires appropriate permissions and capabilities on both platforms.**
+
+**Parameters:**
+
+- `options` (ConnectionOptions):
+  - `ssid` (string): The SSID of the network
+  - `password?` (string): Optional password for secured networks
+  - `isWEP?` (boolean): Whether the network uses WEP encryption
+
+**Returns:** Promise<void>
+
+#### `disconnect()`
+
+Disconnects from the current Wi-Fi network.
+
+**Returns:** Promise<void>
+
+#### `getIPAddress()`
+
+Gets IP address information for the current Wi-Fi connection.
+
+**Returns:** Promise<string | null>
+
 ### Event Management
 
 #### `addNetworkFoundListener(callback)`
@@ -392,15 +493,38 @@ Adds an event listener.
 interface WifiNetwork {
   ssid: string
   bssid: string
-  rssi: number
-  frequency: number
-  channel?: number
+  rssi?: number // Not available on iOS
+  frequency?: number // Not available on iOS
+  channel?: number // Not available on iOS
   capabilities?: string
   isSecure?: boolean
   timestamp?: number
 }
 ```
 
+#### `CurrentNetworkInfo`
+
+```typescript
+interface CurrentNetworkInfo {
+  ssid: string
+  bssid: string
+  ipAddress?: string
+  subnetMask?: string
+  gateway?: string
+  dnsServers?: string[]
+}
+```
+
+#### `ConnectionOptions`
+
+```typescript
+interface ConnectionOptions {
+  ssid: string
+  password?: string
+  isWEP?: boolean
+}
+```
+
 #### `WifiFingerprint`
 
 ```typescript

package/ios/HybridMunimWifi.swift

@@ -6,217 +6,310 @@
 //
 
 import Foundation
-import CoreWLAN
-import CoreLocation
 import NetworkExtension
+import CoreLocation
+import SystemConfiguration.CaptiveNetwork
+import NitroModules
 
 class HybridMunimWifi: HybridMunimWifiSpec {
-    private let wifiClient = CWWiFiClient.shared()
     private var locationManager: CLLocationManager?
-    private var scanResults: [CWNetwork] = []
+    private var scanResults: [WifiNetwork] = []
     private var isScanning = false
     
-    private func getFrequencyChannel(frequency: Int) -> Int {
-        // Convert frequency (MHz) to channel number
-        if frequency >= 2412 && frequency <= 2484 {
-            // 2.4 GHz band
-            return ((frequency - 2412) / 5) + 1
-        } else if frequency >= 5170 && frequency <= 5825 {
-            // 5 GHz band
-            return ((frequency - 5170) / 5) + 36
-        }
-        return 0
-    }
-    
-    private func convertNetwork(_ network: CWNetwork) -> WifiNetwork {
-        guard let channel = network.wlanChannel else {
-            return WifiNetwork(
-                ssid: network.ssid ?? "",
-                bssid: network.bssid ?? "",
-                rssi: Int(network.rssiValue),
-                frequency: 0,
-                channel: 0,
-                capabilities: network.ies?.description ?? "",
-                isSecure: false,
-                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
-            )
-        }
-        
-        let channelNumber = Int(channel.channelNumber)
-        let frequency: Int
-        if channel.channelBand == .band2GHz {
-            frequency = 2412 + (channelNumber - 1) * 5
-        } else {
-            frequency = 5170 + (channelNumber - 36) * 5
-        }
-        
-        let isSecure = network.supportsSecurity(.WPA2Personal) || 
-                      network.supportsSecurity(.WPA3Personal) ||
-                      network.supportsSecurity(.WPAEnterprise) ||
-                      network.supportsSecurity(.WPA3Enterprise)
-        
-        return WifiNetwork(
-            ssid: network.ssid ?? "",
-            bssid: network.bssid ?? "",
-            rssi: Int(network.rssiValue),
-            frequency: frequency,
-            channel: channelNumber,
-            capabilities: network.ies?.description ?? "",
-            isSecure: isSecure,
-            timestamp: Int64(Date().timeIntervalSince1970 * 1000)
-        )
-    }
+    // Note: iOS has very limited Wi-Fi scanning capabilities
+    // CoreWLAN is macOS only - not available on iOS
+    // iOS can only get SSID/BSSID, not RSSI, channel, or frequency
     
-    func isWifiEnabled() throws -> Bool {
-        return wifiClient.interface()?.powerOn() ?? false
+    func isWifiEnabled() throws -> Promise<Bool> {
+        let promise = Promise<Bool>()
+        // On iOS, we can't directly check if Wi-Fi is enabled
+        // We can infer it by checking if we can get current network
+        if let _ = try? getCurrentNetworkSync() {
+            promise.resolve(withResult: true)
+        } else {
+            promise.resolve(withResult: false)
+        }
+        return promise
     }
     
-    func requestWifiPermission() throws -> Bool {
-        // On iOS, Wi-Fi scanning requires location permission
+    func requestWifiPermission() throws -> Promise<Bool> {
+        let promise = Promise<Bool>()
         let locationManager = CLLocationManager()
         self.locationManager = locationManager
         
         let status = locationManager.authorizationStatus
-        return status == .authorizedWhenInUse || status == .authorizedAlways
+        let hasPermission = status == .authorizedWhenInUse || status == .authorizedAlways
+        promise.resolve(withResult: hasPermission)
+        return promise
     }
     
-    func scanNetworks(maxResults: Double?, timeout: Double?) throws -> [WifiNetwork] {
-        guard let interface = wifiClient.interface() else {
-            throw NSError(domain: "MunimWifi", code: 1, userInfo: [NSLocalizedDescriptionKey: "Wi-Fi interface not available"])
-        }
+    // Helper to get current network synchronously
+    private func getCurrentNetworkSync() -> CurrentNetworkInfo? {
+        var result: CurrentNetworkInfo? = nil
+        let semaphore = DispatchSemaphore(value: 0)
         
-        guard interface.powerOn() else {
-            throw NSError(domain: "MunimWifi", code: 2, userInfo: [NSLocalizedDescriptionKey: "Wi-Fi is not enabled"])
+        NEHotspotNetwork.fetchCurrent { network in
+            if let network = network {
+                result = CurrentNetworkInfo(
+                    ssid: network.ssid,
+                    bssid: network.bssid ?? ""
+                )
+            }
+            semaphore.signal()
         }
         
-        // Check location permission
-        let locationManager = CLLocationManager()
-        let status = locationManager.authorizationStatus
-        guard status == .authorizedWhenInUse || status == .authorizedAlways else {
-            throw NSError(domain: "MunimWifi", code: 3, userInfo: [NSLocalizedDescriptionKey: "Location permission not granted"])
-        }
+        _ = semaphore.wait(timeout: .now() + 5)
+        return result
+    }
+    
+    func scanNetworks(options: ScanOptions?) throws -> Promise<[WifiNetwork]> {
+        let promise = Promise<[WifiNetwork]>()
+        // iOS limitation: Cannot scan for networks directly
+        // Only can get current connected network
+        // For scanning, we can only return the current network if connected
+        // This is a major iOS limitation
         
-        do {
-            let networks = try interface.scanForNetworks(withName: nil)
-            scanResults = networks
-            
-            let wifiNetworks = networks.map { convertNetwork($0) }
-            let max = maxResults.map { Int($0) } ?? wifiNetworks.count
-            return Array(wifiNetworks.prefix(max))
-        } catch {
-            throw error
+        if let current = try? getCurrentNetworkSync() {
+            let network = WifiNetwork(
+                ssid: current.ssid,
+                bssid: current.bssid,
+                rssi: nil, // Not available on iOS
+                frequency: nil, // Not available on iOS
+                channel: nil, // Not available on iOS
+                capabilities: nil,
+                isSecure: nil,
+                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+            )
+            scanResults = [network]
+            promise.resolve(withResult: [network])
+        } else {
+            // Return empty array if not connected
+            promise.resolve(withResult: [])
         }
+        return promise
     }
     
-    func startScan(maxResults: Double?, timeout: Double?) throws {
+    func startScan(options: ScanOptions?) throws {
         isScanning = true
-        
-        guard let interface = wifiClient.interface() else {
-            isScanning = false
-            return
-        }
-        
-        guard interface.powerOn() else {
-            isScanning = false
-            return
-        }
-        
-        // Check location permission
-        let locationManager = CLLocationManager()
-        let status = locationManager.authorizationStatus
-        guard status == .authorizedWhenInUse || status == .authorizedAlways else {
-            isScanning = false
-            return
-        }
-        
-        // Start scanning in background
-        DispatchQueue.global(qos: .background).async { [weak self] in
-            guard let self = self else { return }
-            
-            do {
-                let networks = try interface.scanForNetworks(withName: nil)
-                self.scanResults = networks
-                self.isScanning = false
-            } catch {
-                self.isScanning = false
-            }
+        // iOS limitation: Cannot continuously scan
+        // Just get current network once
+        if let current = try? getCurrentNetworkSync() {
+            let network = WifiNetwork(
+                ssid: current.ssid,
+                bssid: current.bssid,
+                rssi: nil,
+                frequency: nil,
+                channel: nil,
+                capabilities: nil,
+                isSecure: nil,
+                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+            )
+            scanResults = [network]
         }
+        isScanning = false
     }
     
     func stopScan() throws {
         isScanning = false
     }
     
-    func getSSIDs() throws -> [String] {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        return networks.compactMap { $0.ssid }.unique()
+    func getSSIDs() throws -> Promise<[String]> {
+        let promise = Promise<[String]>()
+        // iOS limitation: Can only get current network SSID
+        if let current = try? getCurrentNetworkSync() {
+            promise.resolve(withResult: [current.ssid])
+        } else {
+            promise.resolve(withResult: [])
+        }
+        return promise
     }
     
-    func getWifiFingerprint() throws -> WifiFingerprint {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        let wifiNetworks = networks.map { convertNetwork($0) }
+    func getWifiFingerprint() throws -> Promise<WifiFingerprint> {
+        let promise = Promise<WifiFingerprint>()
+        // iOS limitation: Can only get current network, no RSSI/channel/frequency
+        var networks: [WifiNetwork] = scanResults
+        if networks.isEmpty {
+            if let current = try? getCurrentNetworkSync() {
+                networks = [WifiNetwork(
+                    ssid: current.ssid,
+                    bssid: current.bssid,
+                    rssi: nil,
+                    frequency: nil,
+                    channel: nil,
+                    capabilities: nil,
+                    isSecure: nil,
+                    timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+                )]
+            }
+        }
         
-        return WifiFingerprint(
-            networks: wifiNetworks,
+        let fingerprint = WifiFingerprint(
+            networks: networks,
             timestamp: Int64(Date().timeIntervalSince1970 * 1000)
         )
+        promise.resolve(withResult: fingerprint)
+        return promise
     }
     
-    func getRSSI(ssid: String) throws -> Double? {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        let network = networks.first { $0.ssid == ssid }
-        return network.map { Double($0.rssiValue) }
+    func getRSSI(ssid: String) throws -> Promise<Variant_NullType_Double> {
+        let promise = Promise<Variant_NullType_Double>()
+        // iOS limitation: RSSI not available for scanned networks
+        promise.resolve(withResult: .first(NullType()))
+        return promise
     }
     
-    func getBSSID(ssid: String) throws -> String? {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        let network = networks.first { $0.ssid == ssid }
-        return network?.bssid
+    func getBSSID(ssid: String) throws -> Promise<Variant_NullType_String> {
+        let promise = Promise<Variant_NullType_String>()
+        if let current = try? getCurrentNetworkSync(), current.ssid == ssid {
+            promise.resolve(withResult: .second(current.bssid))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
+        }
+        return promise
+    }
+    
+    func getChannelInfo(ssid: String) throws -> Promise<Variant_NullType_ChannelInfo> {
+        let promise = Promise<Variant_NullType_ChannelInfo>()
+        // iOS limitation: Channel and frequency not available
+        promise.resolve(withResult: .first(NullType()))
+        return promise
     }
     
-    func getChannelInfo(ssid: String) throws -> ChannelInfo? {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        guard let network = networks.first(where: { $0.ssid == ssid }),
-              let channel = network.wlanChannel else {
-            return nil
+    func getNetworkInfo(ssid: String) throws -> Promise<Variant_NullType_WifiNetwork> {
+        let promise = Promise<Variant_NullType_WifiNetwork>()
+        if let current = try? getCurrentNetworkSync(), current.ssid == ssid {
+            let network = WifiNetwork(
+                ssid: current.ssid,
+                bssid: current.bssid,
+                rssi: nil, // Not available on iOS
+                frequency: nil, // Not available on iOS
+                channel: nil, // Not available on iOS
+                capabilities: nil,
+                isSecure: nil,
+                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+            )
+            promise.resolve(withResult: .second(network))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
+        }
+        return promise
+    }
+    
+    func getCurrentNetwork() throws -> Promise<Variant_NullType_CurrentNetworkInfo> {
+        let promise = Promise<Variant_NullType_CurrentNetworkInfo>()
+        let semaphore = DispatchSemaphore(value: 0)
+        var result: CurrentNetworkInfo? = nil
+        
+        NEHotspotNetwork.fetchCurrent { network in
+            if let network = network {
+                result = CurrentNetworkInfo(
+                    ssid: network.ssid,
+                    bssid: network.bssid ?? ""
+                )
+            }
+            semaphore.signal()
         }
         
-        let channelNumber = Int(channel.channelNumber)
-        let frequency: Int
-        if channel.channelBand == .band2GHz {
-            frequency = 2412 + (channelNumber - 1) * 5
+        _ = semaphore.wait(timeout: .now() + 5)
+        
+        if let result = result {
+            promise.resolve(withResult: .second(result))
         } else {
-            frequency = 5170 + (channelNumber - 36) * 5
+            promise.resolve(withResult: .first(NullType()))
         }
+        return promise
+    }
+    
+    func connectToNetwork(options: ConnectionOptions) throws -> Promise<Void> {
+        let promise = Promise<Void>()
+        let configuration: NEHotspotConfiguration
         
-        return ChannelInfo(
-            channel: channelNumber,
-            frequency: frequency
-        )
+        if let password = options.password {
+            if options.isWEP == true {
+                configuration = NEHotspotConfiguration(ssid: options.ssid, passphrase: password, isWEP: true)
+            } else {
+                configuration = NEHotspotConfiguration(ssid: options.ssid, passphrase: password, isWEP: false)
+            }
+        } else {
+            configuration = NEHotspotConfiguration(ssid: options.ssid)
+        }
+        
+        configuration.joinOnce = false
+        
+        let semaphore = DispatchSemaphore(value: 0)
+        var error: Error?
+        
+        NEHotspotConfigurationManager.shared.apply(configuration) { applyError in
+            error = applyError
+            semaphore.signal()
+        }
+        
+        _ = semaphore.wait(timeout: .now() + 30)
+        
+        if let error = error {
+            promise.reject(withError: error)
+        } else {
+            promise.resolve()
+        }
+        return promise
     }
     
-    func getNetworkInfo(ssid: String) throws -> WifiNetwork? {
-        let networks = scanResults.isEmpty ? (try? wifiClient.interface()?.scanForNetworks(withName: nil)) ?? [] : scanResults
-        guard let network = networks.first(where: { $0.ssid == ssid }) else {
-            return nil
+    func disconnect() throws -> Promise<Void> {
+        let promise = Promise<Void>()
+        // On iOS, we can't directly disconnect from Wi-Fi
+        // We can only remove saved configurations
+        // This is an iOS limitation
+        // Note: This will remove the network from saved networks, not disconnect immediately
+        if let current = try? getCurrentNetworkSync() {
+            NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: current.ssid)
+        }
+        promise.resolve()
+        return promise
+    }
+    
+    func getIPAddress() throws -> Promise<Variant_NullType_String> {
+        let promise = Promise<Variant_NullType_String>()
+        var address: String?
+        var ifaddr: UnsafeMutablePointer<ifaddrs>?
+        
+        guard getifaddrs(&ifaddr) == 0 else { return nil }
+        defer { freeifaddrs(ifaddr) }
+        
+        guard var ptr = ifaddr else { return nil }
+        
+        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" || name == "en1" {
+                    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)
+                    break
+                }
+            }
+        }
+        
+        if let address = address {
+            promise.resolve(withResult: .second(address))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
         }
-        return convertNetwork(network)
+        return promise
     }
     
     func addListener(eventName: String) throws {
-        // Event listener implementation can be added here if needed
         print("[MunimWifi] Adding listener for event: \(eventName)")
+        // Note: iOS has limited event support for Wi-Fi changes
     }
     
     func removeListeners(count: Double) throws {
-        // Event listener removal implementation can be added here if needed
         print("[MunimWifi] Removing \(count) listeners")
     }
 }
-
-extension Array where Element: Hashable {
-    func unique() -> [Element] {
-        var seen = Set<Element>()
-        return filter { seen.insert($0).inserted }
-    }
-}