munim-wifi 0.1.1 → 0.1.2

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
@@ -55,7 +62,8 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         return result
     }
     
-    func scanNetworks(maxResults: Double?, timeout: Double?) throws -> [WifiNetwork] {
+    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
@@ -73,14 +81,15 @@ class HybridMunimWifi: HybridMunimWifiSpec {
                 timestamp: Int64(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
@@ -104,44 +113,72 @@ 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: Int64(Date().timeIntervalSince1970 * 1000)
+                )]
+            }
+        }
         
-        return WifiFingerprint(
+        let fingerprint = WifiFingerprint(
             networks: networks,
             timestamp: Int64(Date().timeIntervalSince1970 * 1000)
         )
+        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(NullType()))
+        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(NullType()))
         }
-        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(NullType()))
+        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
@@ -151,13 +188,17 @@ class HybridMunimWifi: HybridMunimWifiSpec {
                 isSecure: nil,
                 timestamp: Int64(Date().timeIntervalSince1970 * 1000)
             )
+            promise.resolve(withResult: .second(network))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
         }
-        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 {
@@ -170,10 +211,17 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         }
         
         _ = semaphore.wait(timeout: .now() + 5)
-        return result
+        
+        if let result = result {
+            promise.resolve(withResult: .second(result))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
+        }
+        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 +247,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,9 +263,12 @@ class HybridMunimWifi: HybridMunimWifiSpec {
         if let current = try? getCurrentNetworkSync() {
             NEHotspotConfigurationManager.shared.removeConfiguration(forSSID: current.ssid)
         }
+        promise.resolve()
+        return promise
     }
     
-    func getIPAddress() throws -> String? {
+    func getIPAddress() throws -> Promise<Variant_NullType_String> {
+        let promise = Promise<Variant_NullType_String>()
         var address: String?
         var ifaddr: UnsafeMutablePointer<ifaddrs>?
         
@@ -241,7 +296,12 @@ class HybridMunimWifi: HybridMunimWifiSpec {
             }
         }
         
-        return address
+        if let address = address {
+            promise.resolve(withResult: .second(address))
+        } else {
+            promise.resolve(withResult: .first(NullType()))
+        }
+        return promise
     }
     
     func addListener(eventName: String) throws {

package/package.json

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