munim-wifi 0.1.1 → 0.1.3

package/ios/HybridMunimWifi.swift

@@ -9,6 +9,7 @@ import Foundation
 import NetworkExtension
 import CoreLocation
 import SystemConfiguration.CaptiveNetwork
+import NitroModules
 
 class HybridMunimWifi: HybridMunimWifiSpec {
     private var locationManager: CLLocationManager?
@@ -19,21 +20,27 @@ class HybridMunimWifi: HybridMunimWifiSpec {
     // CoreWLAN is macOS only - not available on iOS
     // iOS can only get SSID/BSSID, not RSSI, channel, or frequency
     
-    func isWifiEnabled() throws -> Bool {
+    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() {
-            return true
+            promise.resolve(withResult: true)
+        } else {
+            promise.resolve(withResult: false)
         }
-        return false
+        return promise
     }
     
-    func requestWifiPermission() throws -> Bool {
+    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
     }
     
     // Helper to get current network synchronously
@@ -43,9 +50,15 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         
         NEHotspotNetwork.fetchCurrent { network in
             if let network = network {
+                // Get IP address
+                let ipAddress = self.getIPAddressSync()
                 result = CurrentNetworkInfo(
                     ssid: network.ssid,
-                    bssid: network.bssid ?? ""
+                    bssid: network.bssid ?? "",
+                    ipAddress: ipAddress,
+                    subnetMask: nil,
+                    gateway: nil,
+                    dnsServers: nil
                 )
             }
             semaphore.signal()
@@ -55,7 +68,40 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         return result
     }
     
-    func scanNetworks(maxResults: Double?, timeout: Double?) throws -> [WifiNetwork] {
+    // Helper to get IP address synchronously
+    private func getIPAddressSync() -> 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
+                }
+            }
+        }
+        
+        return address
+    }
+    
+    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
@@ -70,17 +116,18 @@ class HybridMunimWifi: HybridMunimWifiSpec {
                 channel: nil, // Not available on iOS
                 capabilities: nil,
                 isSecure: nil,
-                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+                timestamp: Date().timeIntervalSince1970 * 1000
             )
             scanResults = [network]
-            return [network]
+            promise.resolve(withResult: [network])
+        } else {
+            // Return empty array if not connected
+            promise.resolve(withResult: [])
         }
-        
-        // Return empty array if not connected
-        return []
+        return promise
     }
     
-    func startScan(maxResults: Double?, timeout: Double?) throws {
+    func startScan(options: ScanOptions?) throws {
         isScanning = true
         // iOS limitation: Cannot continuously scan
         // Just get current network once
@@ -93,7 +140,7 @@ class HybridMunimWifi: HybridMunimWifiSpec {
                 channel: nil,
                 capabilities: nil,
                 isSecure: nil,
-                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+                timestamp: Date().timeIntervalSince1970 * 1000
             )
             scanResults = [network]
         }
@@ -104,44 +151,73 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         isScanning = false
     }
     
-    func getSSIDs() throws -> [String] {
+    func getSSIDs() throws -> Promise<[String]> {
+        let promise = Promise<[String]>()
         // iOS limitation: Can only get current network SSID
         if let current = try? getCurrentNetworkSync() {
-            return [current.ssid]
+            promise.resolve(withResult: [current.ssid])
+        } else {
+            promise.resolve(withResult: [])
         }
-        return []
+        return promise
     }
     
-    func getWifiFingerprint() throws -> WifiFingerprint {
+    func getWifiFingerprint() throws -> Promise<WifiFingerprint> {
+        let promise = Promise<WifiFingerprint>()
         // iOS limitation: Can only get current network, no RSSI/channel/frequency
-        let networks = scanResults.isEmpty ? (try? scanNetworks(maxResults: nil, timeout: nil)) ?? [] : scanResults
+        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: Date().timeIntervalSince1970 * 1000
+                )]
+            }
+        }
         
-        return WifiFingerprint(
+        let fingerprint = WifiFingerprint(
             networks: networks,
-            timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+            timestamp: Date().timeIntervalSince1970 * 1000,
+            location: nil
         )
+        promise.resolve(withResult: fingerprint)
+        return promise
     }
     
-    func getRSSI(ssid: String) throws -> Double? {
+    func getRSSI(ssid: String) throws -> Promise<Variant_NullType_Double> {
+        let promise = Promise<Variant_NullType_Double>()
         // iOS limitation: RSSI not available for scanned networks
-        return nil
+        promise.resolve(withResult: .first(margelo.nitro.NullType.null))
+        return promise
     }
     
-    func getBSSID(ssid: String) throws -> String? {
+    func getBSSID(ssid: String) throws -> Promise<Variant_NullType_String> {
+        let promise = Promise<Variant_NullType_String>()
         if let current = try? getCurrentNetworkSync(), current.ssid == ssid {
-            return current.bssid
+            promise.resolve(withResult: .second(current.bssid))
+        } else {
+            promise.resolve(withResult: .first(margelo.nitro.NullType.null))
         }
-        return nil
+        return promise
     }
     
-    func getChannelInfo(ssid: String) throws -> ChannelInfo? {
+    func getChannelInfo(ssid: String) throws -> Promise<Variant_NullType_ChannelInfo> {
+        let promise = Promise<Variant_NullType_ChannelInfo>()
         // iOS limitation: Channel and frequency not available
-        return nil
+        promise.resolve(withResult: .first(margelo.nitro.NullType.null))
+        return promise
     }
     
-    func getNetworkInfo(ssid: String) throws -> WifiNetwork? {
+    func getNetworkInfo(ssid: String) throws -> Promise<Variant_NullType_WifiNetwork> {
+        let promise = Promise<Variant_NullType_WifiNetwork>()
         if let current = try? getCurrentNetworkSync(), current.ssid == ssid {
-            return WifiNetwork(
+            let network = WifiNetwork(
                 ssid: current.ssid,
                 bssid: current.bssid,
                 rssi: nil, // Not available on iOS
@@ -149,31 +225,48 @@ class HybridMunimWifi: HybridMunimWifiSpec {
                 channel: nil, // Not available on iOS
                 capabilities: nil,
                 isSecure: nil,
-                timestamp: Int64(Date().timeIntervalSince1970 * 1000)
+                timestamp: Date().timeIntervalSince1970 * 1000
             )
+            promise.resolve(withResult: .second(network))
+        } else {
+            promise.resolve(withResult: .first(margelo.nitro.NullType.null))
         }
-        return nil
+        return promise
     }
     
-    func getCurrentNetwork() throws -> CurrentNetworkInfo? {
-        var result: CurrentNetworkInfo? = nil
+    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 {
+                // Get IP address
+                let ipAddress = self.getIPAddressSync()
                 result = CurrentNetworkInfo(
                     ssid: network.ssid,
-                    bssid: network.bssid ?? ""
+                    bssid: network.bssid ?? "",
+                    ipAddress: ipAddress,
+                    subnetMask: nil,
+                    gateway: nil,
+                    dnsServers: nil
                 )
             }
             semaphore.signal()
         }
         
         _ = semaphore.wait(timeout: .now() + 5)
-        return result
+        
+        if let result = result {
+            promise.resolve(withResult: .second(result))
+        } else {
+            promise.resolve(withResult: .first(margelo.nitro.NullType.null))
+        }
+        return promise
     }
     
-    func connectToNetwork(options: ConnectionOptions) throws {
+    func connectToNetwork(options: ConnectionOptions) throws -> Promise<Void> {
+        let promise = Promise<Void>()
         let configuration: NEHotspotConfiguration
         
         if let password = options.password {
@@ -199,11 +292,15 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         _ = semaphore.wait(timeout: .now() + 30)
         
         if let error = error {
-            throw error
+            promise.reject(withError: error)
+        } else {
+            promise.resolve()
         }
+        return promise
     }
     
-    func disconnect() throws {
+    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
@@ -211,37 +308,20 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         if let current = try? getCurrentNetworkSync() {
             NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: current.ssid)
         }
+        promise.resolve()
+        return promise
     }
     
-    func getIPAddress() throws -> String? {
-        var address: String?
-        var ifaddr: UnsafeMutablePointer<ifaddrs>?
-        
-        guard getifaddrs(&ifaddr) == 0 else { return nil }
-        defer { freeifaddrs(ifaddr) }
+    func getIPAddress() throws -> Promise<Variant_NullType_String> {
+        let promise = Promise<Variant_NullType_String>()
+        let address = getIPAddressSync()
         
-        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(margelo.nitro.NullType.null))
         }
-        
-        return address
+        return promise
     }
     
     func addListener(eventName: String) throws {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-wifi",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "munim-wifi is a react native package built with Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",