munim-wifi 0.1.0 → 0.1.1

package/nitrogen/generated/ios/swift/HybridMunimWifiSpec_cxx.swift

@@ -358,6 +358,96 @@ open class HybridMunimWifiSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getCurrentNetwork() -> bridge.Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____ {
+    do {
+      let __result = try self.__implementation.getCurrentNetwork()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_nitro__NullType__CurrentNetworkInfo_ in
+              switch __result {
+                case .first(let __value):
+                  return bridge.create_std__variant_nitro__NullType__CurrentNetworkInfo_(margelo.nitro.NullType.null)
+                case .second(let __value):
+                  return bridge.create_std__variant_nitro__NullType__CurrentNetworkInfo_(__value)
+              }
+            }().variant) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func connectToNetwork(options: ConnectionOptions) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.connectToNetwork(options: options)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func disconnect() -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.disconnect()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getIPAddress() -> bridge.Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ {
+    do {
+      let __result = try self.__implementation.getIPAddress()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_nitro__NullType__std__string_ in
+              switch __result {
+                case .first(let __value):
+                  return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null)
+                case .second(let __value):
+                  return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value))
+              }
+            }().variant) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func addListener(eventName: std.string) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/Variant_NullType_CurrentNetworkInfo.swift

@@ -0,0 +1,18 @@
+///
+/// Variant_NullType_CurrentNetworkInfo.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `null | struct`
+ */
+@frozen
+public indirect enum Variant_NullType_CurrentNetworkInfo {
+  case first(NullType)
+  case second(CurrentNetworkInfo)
+}

package/nitrogen/generated/ios/swift/WifiNetwork.swift

@@ -19,8 +19,20 @@ public extension WifiNetwork {
   /**
    * Create a new instance of `WifiNetwork`.
    */
-  init(ssid: String, bssid: String, rssi: Double, frequency: Double, channel: Double?, capabilities: String?, isSecure: Bool?, timestamp: Double?) {
-    self.init(std.string(ssid), std.string(bssid), rssi, frequency, { () -> bridge.std__optional_double_ in
+  init(ssid: String, bssid: String, rssi: Double?, frequency: Double?, channel: Double?, capabilities: String?, isSecure: Bool?, timestamp: Double?) {
+    self.init(std.string(ssid), std.string(bssid), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = rssi {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = frequency {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
       if let __unwrappedValue = channel {
         return bridge.create_std__optional_double_(__unwrappedValue)
       } else {
@@ -58,13 +70,13 @@ public extension WifiNetwork {
   }
   
   @inline(__always)
-  var rssi: Double {
-    return self.__rssi
+  var rssi: Double? {
+    return self.__rssi.value
   }
   
   @inline(__always)
-  var frequency: Double {
-    return self.__frequency
+  var frequency: Double? {
+    return self.__frequency.value
   }
   
   @inline(__always)

package/nitrogen/generated/shared/c++/ConnectionOptions.hpp

@@ -0,0 +1,92 @@
+///
+/// ConnectionOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::munimwifi {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ConnectionOptions).
+   */
+  struct ConnectionOptions final {
+  public:
+    std::string ssid     SWIFT_PRIVATE;
+    std::optional<std::string> password     SWIFT_PRIVATE;
+    std::optional<bool> isWEP     SWIFT_PRIVATE;
+
+  public:
+    ConnectionOptions() = default;
+    explicit ConnectionOptions(std::string ssid, std::optional<std::string> password, std::optional<bool> isWEP): ssid(ssid), password(password), isWEP(isWEP) {}
+
+  public:
+    friend bool operator==(const ConnectionOptions& lhs, const ConnectionOptions& rhs) = default;
+  };
+
+} // namespace margelo::nitro::munimwifi
+
+namespace margelo::nitro {
+
+  // C++ ConnectionOptions <> JS ConnectionOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::munimwifi::ConnectionOptions> final {
+    static inline margelo::nitro::munimwifi::ConnectionOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::munimwifi::ConnectionOptions(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "password"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isWEP")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::munimwifi::ConnectionOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ssid"), JSIConverter<std::string>::toJSI(runtime, arg.ssid));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "password"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.password));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isWEP"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isWEP));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "password")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isWEP")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/CurrentNetworkInfo.hpp

@@ -0,0 +1,105 @@
+///
+/// CurrentNetworkInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::munimwifi {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CurrentNetworkInfo).
+   */
+  struct CurrentNetworkInfo final {
+  public:
+    std::string ssid     SWIFT_PRIVATE;
+    std::string bssid     SWIFT_PRIVATE;
+    std::optional<std::string> ipAddress     SWIFT_PRIVATE;
+    std::optional<std::string> subnetMask     SWIFT_PRIVATE;
+    std::optional<std::string> gateway     SWIFT_PRIVATE;
+    std::optional<std::vector<std::string>> dnsServers     SWIFT_PRIVATE;
+
+  public:
+    CurrentNetworkInfo() = default;
+    explicit CurrentNetworkInfo(std::string ssid, std::string bssid, std::optional<std::string> ipAddress, std::optional<std::string> subnetMask, std::optional<std::string> gateway, std::optional<std::vector<std::string>> dnsServers): ssid(ssid), bssid(bssid), ipAddress(ipAddress), subnetMask(subnetMask), gateway(gateway), dnsServers(dnsServers) {}
+
+  public:
+    friend bool operator==(const CurrentNetworkInfo& lhs, const CurrentNetworkInfo& rhs) = default;
+  };
+
+} // namespace margelo::nitro::munimwifi
+
+namespace margelo::nitro {
+
+  // C++ CurrentNetworkInfo <> JS CurrentNetworkInfo (object)
+  template <>
+  struct JSIConverter<margelo::nitro::munimwifi::CurrentNetworkInfo> final {
+    static inline margelo::nitro::munimwifi::CurrentNetworkInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::munimwifi::CurrentNetworkInfo(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bssid"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ipAddress"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "subnetMask"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gateway"))),
+        JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dnsServers")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::munimwifi::CurrentNetworkInfo& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ssid"), JSIConverter<std::string>::toJSI(runtime, arg.ssid));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "bssid"), JSIConverter<std::string>::toJSI(runtime, arg.bssid));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ipAddress"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.ipAddress));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "subnetMask"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.subnetMask));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "gateway"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.gateway));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "dnsServers"), JSIConverter<std::optional<std::vector<std::string>>>::toJSI(runtime, arg.dnsServers));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bssid")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ipAddress")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "subnetMask")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gateway")))) return false;
+      if (!JSIConverter<std::optional<std::vector<std::string>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dnsServers")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridMunimWifiSpec.cpp

@@ -25,6 +25,10 @@ namespace margelo::nitro::munimwifi {
       prototype.registerHybridMethod("getBSSID", &HybridMunimWifiSpec::getBSSID);
       prototype.registerHybridMethod("getChannelInfo", &HybridMunimWifiSpec::getChannelInfo);
       prototype.registerHybridMethod("getNetworkInfo", &HybridMunimWifiSpec::getNetworkInfo);
+      prototype.registerHybridMethod("getCurrentNetwork", &HybridMunimWifiSpec::getCurrentNetwork);
+      prototype.registerHybridMethod("connectToNetwork", &HybridMunimWifiSpec::connectToNetwork);
+      prototype.registerHybridMethod("disconnect", &HybridMunimWifiSpec::disconnect);
+      prototype.registerHybridMethod("getIPAddress", &HybridMunimWifiSpec::getIPAddress);
       prototype.registerHybridMethod("addListener", &HybridMunimWifiSpec::addListener);
       prototype.registerHybridMethod("removeListeners", &HybridMunimWifiSpec::removeListeners);
     });

package/nitrogen/generated/shared/c++/HybridMunimWifiSpec.hpp

@@ -21,6 +21,10 @@ namespace margelo::nitro::munimwifi { struct ScanOptions; }
 namespace margelo::nitro::munimwifi { struct WifiFingerprint; }
 // Forward declaration of `ChannelInfo` to properly resolve imports.
 namespace margelo::nitro::munimwifi { struct ChannelInfo; }
+// Forward declaration of `CurrentNetworkInfo` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct CurrentNetworkInfo; }
+// Forward declaration of `ConnectionOptions` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct ConnectionOptions; }
 
 #include <NitroModules/Promise.hpp>
 #include "WifiNetwork.hpp"
@@ -32,6 +36,8 @@ namespace margelo::nitro::munimwifi { struct ChannelInfo; }
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include "ChannelInfo.hpp"
+#include "CurrentNetworkInfo.hpp"
+#include "ConnectionOptions.hpp"
 
 namespace margelo::nitro::munimwifi {
 
@@ -75,6 +81,10 @@ namespace margelo::nitro::munimwifi {
       virtual std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getBSSID(const std::string& ssid) = 0;
       virtual std::shared_ptr<Promise<std::variant<nitro::NullType, ChannelInfo>>> getChannelInfo(const std::string& ssid) = 0;
       virtual std::shared_ptr<Promise<std::variant<nitro::NullType, WifiNetwork>>> getNetworkInfo(const std::string& ssid) = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>> getCurrentNetwork() = 0;
+      virtual std::shared_ptr<Promise<void>> connectToNetwork(const ConnectionOptions& options) = 0;
+      virtual std::shared_ptr<Promise<void>> disconnect() = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getIPAddress() = 0;
       virtual void addListener(const std::string& eventName) = 0;
       virtual void removeListeners(double count) = 0;
 

package/nitrogen/generated/shared/c++/WifiNetwork.hpp

@@ -42,8 +42,8 @@ namespace margelo::nitro::munimwifi {
   public:
     std::string ssid     SWIFT_PRIVATE;
     std::string bssid     SWIFT_PRIVATE;
-    double rssi     SWIFT_PRIVATE;
-    double frequency     SWIFT_PRIVATE;
+    std::optional<double> rssi     SWIFT_PRIVATE;
+    std::optional<double> frequency     SWIFT_PRIVATE;
     std::optional<double> channel     SWIFT_PRIVATE;
     std::optional<std::string> capabilities     SWIFT_PRIVATE;
     std::optional<bool> isSecure     SWIFT_PRIVATE;
@@ -51,7 +51,7 @@ namespace margelo::nitro::munimwifi {
 
   public:
     WifiNetwork() = default;
-    explicit WifiNetwork(std::string ssid, std::string bssid, double rssi, double frequency, std::optional<double> channel, std::optional<std::string> capabilities, std::optional<bool> isSecure, std::optional<double> timestamp): ssid(ssid), bssid(bssid), rssi(rssi), frequency(frequency), channel(channel), capabilities(capabilities), isSecure(isSecure), timestamp(timestamp) {}
+    explicit WifiNetwork(std::string ssid, std::string bssid, std::optional<double> rssi, std::optional<double> frequency, std::optional<double> channel, std::optional<std::string> capabilities, std::optional<bool> isSecure, std::optional<double> timestamp): ssid(ssid), bssid(bssid), rssi(rssi), frequency(frequency), channel(channel), capabilities(capabilities), isSecure(isSecure), timestamp(timestamp) {}
 
   public:
     friend bool operator==(const WifiNetwork& lhs, const WifiNetwork& rhs) = default;
@@ -69,8 +69,8 @@ namespace margelo::nitro {
       return margelo::nitro::munimwifi::WifiNetwork(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid"))),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bssid"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rssi"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "frequency"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rssi"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "frequency"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "channel"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "capabilities"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSecure"))),
@@ -81,8 +81,8 @@ namespace margelo::nitro {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ssid"), JSIConverter<std::string>::toJSI(runtime, arg.ssid));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "bssid"), JSIConverter<std::string>::toJSI(runtime, arg.bssid));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "rssi"), JSIConverter<double>::toJSI(runtime, arg.rssi));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "frequency"), JSIConverter<double>::toJSI(runtime, arg.frequency));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "rssi"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.rssi));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "frequency"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.frequency));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "channel"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.channel));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "capabilities"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.capabilities));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "isSecure"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isSecure));
@@ -99,8 +99,8 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ssid")))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bssid")))) return false;
-      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rssi")))) return false;
-      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "frequency")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rssi")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "frequency")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "channel")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "capabilities")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isSecure")))) return false;

package/package.json

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

package/src/index.ts

@@ -7,6 +7,8 @@ import type {
   ScanOptions,
   ChannelInfo,
   Location,
+  CurrentNetworkInfo,
+  ConnectionOptions,
 } from './specs/munim-wifi.nitro'
 
 const MunimWifi =
@@ -127,6 +129,7 @@ export function getChannelInfo(ssid: string): Promise<ChannelInfo | null> {
 
 /**
  * Get all available information for a specific network by SSID.
+ * Note: On iOS, RSSI, channel, and frequency will be undefined.
  *
  * @param ssid - The SSID of the network.
  * @returns Promise resolving to WifiNetwork object, or null if network not found.
@@ -135,6 +138,44 @@ export function getNetworkInfo(ssid: string): Promise<WifiNetwork | null> {
   return MunimWifi.getNetworkInfo(ssid)
 }
 
+/**
+ * Get information about the currently connected Wi-Fi network.
+ *
+ * @returns Promise resolving to current network info, or null if not connected.
+ */
+export function getCurrentNetwork(): Promise<CurrentNetworkInfo | null> {
+  return MunimWifi.getCurrentNetwork()
+}
+
+/**
+ * Connect to a Wi-Fi network.
+ * Note: Requires appropriate permissions and capabilities on both platforms.
+ *
+ * @param options - Connection options including SSID and password.
+ * @returns Promise resolving when connection is attempted.
+ */
+export function connectToNetwork(options: ConnectionOptions): Promise<void> {
+  return MunimWifi.connectToNetwork(options)
+}
+
+/**
+ * Disconnect from the current Wi-Fi network.
+ *
+ * @returns Promise resolving when disconnection is complete.
+ */
+export function disconnect(): Promise<void> {
+  return MunimWifi.disconnect()
+}
+
+/**
+ * Get IP address information for the current Wi-Fi connection.
+ *
+ * @returns Promise resolving to IP address string, or null if not connected.
+ */
+export function getIPAddress(): Promise<string | null> {
+  return MunimWifi.getIPAddress()
+}
+
 // ========== Event Management ==========
 
 /**
@@ -214,6 +255,10 @@ export default {
   getBSSID,
   getChannelInfo,
   getNetworkInfo,
+  getCurrentNetwork,
+  connectToNetwork,
+  disconnect,
+  getIPAddress,
   addNetworkFoundListener,
   addEventListener,
   addListener,

package/src/specs/munim-wifi.nitro.ts

@@ -12,18 +12,35 @@ export interface ChannelInfo {
   frequency: number
 }
 
+// Current network information
+export interface CurrentNetworkInfo {
+  ssid: string
+  bssid: string
+  ipAddress?: string
+  subnetMask?: string
+  gateway?: string
+  dnsServers?: string[]
+}
+
 // Wi-Fi Network information
 export 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
 }
 
+// Connection options
+export interface ConnectionOptions {
+  ssid: string
+  password?: string
+  isWEP?: boolean
+}
+
 // Wi-Fi Fingerprint data
 export interface WifiFingerprint {
   networks: WifiNetwork[]
@@ -84,7 +101,7 @@ export interface MunimWifi
 
   /**
    * Get Wi-Fi fingerprint containing all network information.
-   * This includes SSIDs, BSSIDs, RSSI, channels, and frequencies.
+   * Note: On iOS, RSSI, channel, and frequency are not available.
    *
    * @returns Promise resolving to Wi-Fi fingerprint data.
    */
@@ -92,9 +109,10 @@ export interface MunimWifi
 
   /**
    * Get RSSI (signal strength) for a specific network by SSID.
+   * Note: Not available on iOS - returns null.
    *
    * @param ssid - The SSID of the network.
-   * @returns Promise resolving to RSSI value in dBm, or null if network not found.
+   * @returns Promise resolving to RSSI value in dBm, or null if network not found or not available.
    */
   getRSSI(ssid: string): Promise<number | null>
 
@@ -108,20 +126,52 @@ export interface MunimWifi
 
   /**
    * Get channel and frequency information for a specific network by SSID.
+   * Note: Not available on iOS - returns null.
    *
    * @param ssid - The SSID of the network.
-   * @returns Promise resolving to object with channel and frequency, or null if network not found.
+   * @returns Promise resolving to object with channel and frequency, or null if network not found or not available.
    */
   getChannelInfo(ssid: string): Promise<ChannelInfo | null>
 
   /**
    * Get all available information for a specific network by SSID.
+   * Note: On iOS, RSSI, channel, and frequency will be undefined.
    *
    * @param ssid - The SSID of the network.
    * @returns Promise resolving to WifiNetwork object, or null if network not found.
    */
   getNetworkInfo(ssid: string): Promise<WifiNetwork | null>
 
+  /**
+   * Get information about the currently connected Wi-Fi network.
+   *
+   * @returns Promise resolving to current network info, or null if not connected.
+   */
+  getCurrentNetwork(): Promise<CurrentNetworkInfo | null>
+
+  /**
+   * Connect to a Wi-Fi network.
+   * Note: Requires appropriate permissions and capabilities on both platforms.
+   *
+   * @param options - Connection options including SSID and password.
+   * @returns Promise resolving when connection is attempted.
+   */
+  connectToNetwork(options: ConnectionOptions): Promise<void>
+
+  /**
+   * Disconnect from the current Wi-Fi network.
+   *
+   * @returns Promise resolving when disconnection is complete.
+   */
+  disconnect(): Promise<void>
+
+  /**
+   * Get IP address information for the current Wi-Fi connection.
+   *
+   * @returns Promise resolving to IP address string, or null if not connected.
+   */
+  getIPAddress(): Promise<string | null>
+
   // ========== Event Management ==========
 
   /**