community-cordova-plugin-wifi 1.0.1

package/src/android/PingTask.java

@@ -0,0 +1,56 @@
+package wifiplugin;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.PluginResult;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import org.json.JSONObject;
+import org.apache.cordova.CordovaInterface;
+
+public class PingTask {
+
+    public static void ping(String address, int count, int timeout, CallbackContext callbackContext, CordovaInterface cordova) {
+        cordova.getThreadPool().execute(() -> {
+            try {
+                String command = "/system/bin/ping -c " + count + " -W " + timeout + " " + address;
+                Process process = Runtime.getRuntime().exec(command);
+                BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+
+                int linesRead = 0;
+                String line;
+                String fullResponse = "";
+                while ((line = reader.readLine()) != null) {
+                    linesRead++;
+                    JSONObject progressUpdate = new JSONObject();
+                      // Ensure progress does not exceed 100
+                                    int progress = (int) (((double) linesRead / count) * 100);
+                                    progress = Math.min(progress, 100); // Cap progress at 100
+                    progressUpdate.put("line", line);
+                    if (fullResponse != null && !fullResponse.isEmpty()) {
+                        fullResponse = fullResponse + "\n" + line;
+                    } else {
+                        fullResponse = line;
+                    }
+                    progressUpdate.put("line", line);
+                    progressUpdate.put("fullResponse", fullResponse);
+                    progressUpdate.put("progress", progress);
+                    PluginResult progressResult = new PluginResult(PluginResult.Status.OK, progressUpdate);
+                    progressResult.setKeepCallback(true);
+                    callbackContext.sendPluginResult(progressResult);
+                }
+
+                process.waitFor();
+                JSONObject finalResult = new JSONObject();
+                finalResult.put("line", "");
+                finalResult.put("fullResponse", fullResponse);
+                finalResult.put("progress", 100);
+                finalResult.put("status", "completed");
+                finalResult.put("linesRead", linesRead);
+                PluginResult result = new PluginResult(PluginResult.Status.OK, finalResult);
+                callbackContext.sendPluginResult(result);
+            } catch (Exception e) {
+                callbackContext.error("Error during ping: " + e.getMessage());
+            }
+        });
+    }
+}

package/src/android/WifiDetailsUtils.java

@@ -0,0 +1,78 @@
+package wifiplugin;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.text.format.Formatter;
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.PluginResult;
+import org.json.JSONException;
+import org.json.JSONObject;
+import android.net.DhcpInfo;
+import java.util.Iterator;
+
+public class WifiDetailsUtils {
+
+   public static void getAllWifiDetails(CordovaInterface cordova, CallbackContext callbackContext) {
+       cordova.getThreadPool().execute(() -> {
+           try {
+               WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+               if (wifiManager == null) {
+                   callbackContext.error("WifiManager not available");
+                   return;
+               }
+
+               // Check if Wi-Fi is enabled and supported
+               boolean isWifiEnabled = wifiManager.isWifiEnabled();
+
+               // Get Wi-Fi and DHCP details
+               WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+               DhcpInfo dhcpInfo = wifiManager.getDhcpInfo();
+
+               JSONObject wifiDetails = new JSONObject();
+               wifiDetails.put("iswifienabled", isWifiEnabled);
+               wifiDetails.put("issupportwifi", true); // If wifiManager isn't null, device supports WiFi
+               wifiDetails.put("ssid", wifiInfo.getSSID());
+               wifiDetails.put("bssid", wifiInfo.getBSSID());
+               wifiDetails.put("ip", Formatter.formatIpAddress(wifiInfo.getIpAddress()));
+               wifiDetails.put("mac", wifiInfo.getMacAddress());
+               wifiDetails.put("networkid", wifiInfo.getNetworkId());
+               wifiDetails.put("linkspeed", wifiInfo.getLinkSpeed() + " Mbps");
+               wifiDetails.put("signalstrength", wifiInfo.getRssi());
+               wifiDetails.put("gateway", Formatter.formatIpAddress(dhcpInfo.gateway));
+               wifiDetails.put("rssi", wifiInfo.getRssi());
+               wifiDetails.put("speed", wifiInfo.getLinkSpeed() + " Mbps");
+               wifiDetails.put("frequency", wifiInfo.getFrequency() + " MHz");
+               wifiDetails.put("channel", getChannelFromFrequency(wifiInfo.getFrequency()));
+               wifiDetails.put("dns1", Formatter.formatIpAddress(dhcpInfo.dns1));
+               wifiDetails.put("dns2", Formatter.formatIpAddress(dhcpInfo.dns2));
+
+               // Convert keys to lowercase
+               JSONObject lowerCaseWifiDetails = new JSONObject();
+               Iterator<String> keys = wifiDetails.keys();
+               while (keys.hasNext()) {
+                   String key = keys.next();
+                   lowerCaseWifiDetails.put(key.toLowerCase(), wifiDetails.get(key));
+               }
+
+               PluginResult result = new PluginResult(PluginResult.Status.OK, lowerCaseWifiDetails);
+               callbackContext.sendPluginResult(result);
+           } catch (Exception e) {
+               callbackContext.error("Error getting Wi-Fi details: " + e.getMessage());
+           }
+       });
+   }
+
+
+       // Helper method to get the Wi-Fi channel from frequency
+       private static int getChannelFromFrequency(int frequency) {
+           if (frequency >= 2412 && frequency <= 2484) {
+               return (frequency - 2412) / 5 + 1;
+           } else if (frequency >= 5170 && frequency <= 5825) {
+               return (frequency - 5170) / 5 + 34;
+           }
+           return -1; // Unknown channel
+       }
+}

package/src/android/WifiPlugin.java

@@ -0,0 +1,236 @@
+package wifiplugin;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import android.net.wifi.WifiNetworkSpecifier;
+import android.net.NetworkSpecifier;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.List;
+
+public class WifiPlugin extends CordovaPlugin {
+    private static final String TAG = "WifiPlugin";
+    private static final int MY_PERMISSIONS_REQUEST_WIFI_STATE = 1;
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        if ("getWifiList".equals(action)) {
+            WifiUtils.getWifiList(cordova, callbackContext);
+            return true;
+        } else if ("ping".equals(action)) {
+            String address = args.getString(0);
+            int count = args.getInt(1);
+            int timeout = args.getInt(2);
+            PingTask.ping(address, count, timeout, callbackContext, cordova);
+            return true;
+        } else if ("getIpInfo".equals(action)) {
+            IpInfoUtils.getIpInfo(cordova, callbackContext);
+            return true;
+        } else if ("getSignalStrength".equals(action)) {
+            getSignalStrength(callbackContext);
+            return true;
+        } else if ("getWifiStrength".equals(action)) {
+            getWifiStrength(callbackContext);
+            return true;
+        } else if ("getAllWifiDetails".equals(action)) {
+            WifiDetailsUtils.getAllWifiDetails(cordova, callbackContext);
+            return true;
+        } else if ("getConnectedDevices".equals(action)) {
+            WifiUtils.getConnectedDevices(cordova.getActivity().getApplicationContext(), cordova, callbackContext);
+            return true;
+        } else if ("isConnectedToInternet".equals(action)) {
+            isConnectedToInternet(callbackContext);
+            return true;
+        } else if ("canConnectToInternet".equals(action)) {
+            canConnectToInternet(callbackContext);
+            return true;
+        } else if ("canConnectToRouter".equals(action)) {
+            canConnectToRouter(callbackContext);
+            return true;
+        } else if ("connectToNetwork".equals(action)) {
+            String ssid = args.optString(0);
+            String password = args.optString(1);
+            connectToWifi(ssid, password, callbackContext);
+            return true;
+        } else if ("disconnectFromNetwork".equals(action)) {
+            disconnectFromNetwork(callbackContext);
+            return true;
+        } else if ("isWifiEnabled".equals(action)) {
+            isWifiEnabled(callbackContext);
+            return true;
+        } else if ("wifiToggle".equals(action)) {
+            wifiToggle(callbackContext);
+            return true;
+        }
+        return false;
+    }
+
+    private void getSignalStrength(CallbackContext callbackContext) {
+        WifiUtils.getSignalStrength(cordova.getActivity().getApplicationContext(), callbackContext);
+    }
+
+    private void getWifiStrength(CallbackContext callbackContext) {
+        WifiUtils.getWifiStrength(cordova.getActivity().getApplicationContext(), callbackContext);
+    }
+
+    private void wifiToggle(CallbackContext callbackContext) {
+        cordova.getThreadPool().execute(() -> {
+            try {
+                WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+                if (wifiManager != null) {
+                    wifiManager.setWifiEnabled(!wifiManager.isWifiEnabled());
+                    callbackContext.success();
+                } else {
+                    callbackContext.error("Error toggling Wi-Fi");
+                }
+            } catch (Exception e) {
+                callbackContext.error("Error toggling Wi-Fi: " + e.getMessage());
+            }
+        });
+    }
+
+    private void isWifiEnabled(CallbackContext callbackContext) {
+        try {
+            WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+            boolean isEnabled = wifiManager.isWifiEnabled();
+            callbackContext.success(isEnabled ? 1 : 0);
+        } catch (Exception e) {
+            callbackContext.error("Error checking Wi-Fi status: " + e.getMessage());
+        }
+    }
+
+    private void isConnectedToInternet(CallbackContext callbackContext) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) cordova.getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (connectivityManager != null) {
+            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+            boolean isConnected = activeNetworkInfo != null && activeNetworkInfo.isConnected();
+            callbackContext.success(isConnected ? 1 : 0);
+        } else {
+            callbackContext.error("ConnectivityManager is null");
+        }
+    }
+
+    private void canConnectToInternet(CallbackContext callbackContext) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) cordova.getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (connectivityManager != null) {
+            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
+            boolean canConnect = capabilities != null && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+            callbackContext.success(canConnect ? 1 : 0);
+        } else {
+            callbackContext.error("ConnectivityManager is null");
+        }
+    }
+
+    private void canConnectToRouter(CallbackContext callbackContext) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) cordova.getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (connectivityManager != null) {
+            NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
+            boolean canConnectToRouter = capabilities != null && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
+            callbackContext.success(canConnectToRouter ? 1 : 0);
+        } else {
+            callbackContext.error("ConnectivityManager is null");
+        }
+    }
+
+    public void connectToWifi(String ssid, String password, CallbackContext callbackContext) {
+        WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+
+        if (!wifiManager.isWifiEnabled()) {
+            wifiManager.setWifiEnabled(true);
+        }
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            connectToWifiPreQ(wifiManager, ssid, password, callbackContext);
+        } else {
+            connectToWifiQAndAbove(ssid, password, callbackContext);
+        }
+    }
+
+    private void connectToWifiPreQ(WifiManager wifiManager, String ssid, String password, CallbackContext callbackContext) {
+        WifiConfiguration wifiConfig = new WifiConfiguration();
+        wifiConfig.SSID = "\"" + ssid + "\"";
+        wifiConfig.preSharedKey = "\"" + password + "\"";
+        wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+
+        // Remove existing configurations for the same SSID
+        List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
+        if (configuredNetworks != null) {
+            for (WifiConfiguration existingConfig : configuredNetworks) {
+                if (existingConfig.SSID != null && existingConfig.SSID.equals(wifiConfig.SSID)) {
+                    wifiManager.removeNetwork(existingConfig.networkId);
+                }
+            }
+        }
+
+        int networkId = wifiManager.addNetwork(wifiConfig);
+        if (networkId != -1) {
+            wifiManager.disconnect();
+            wifiManager.enableNetwork(networkId, true);
+            wifiManager.reconnect();
+
+            callbackContext.success("Connected to Wi-Fi network: " + ssid);
+        } else {
+            callbackContext.error("Failed to add Wi-Fi network configuration");
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.Q)
+    private void connectToWifiQAndAbove(String ssid, String password, CallbackContext callbackContext) {
+        WifiNetworkSpecifier.Builder builder = new WifiNetworkSpecifier.Builder()
+           .setSsid(ssid)
+           .setWpa2Passphrase(password);
+WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+       NetworkSpecifier specifier = builder.build();
+
+       NetworkRequest request = new NetworkRequest.Builder()
+           .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+           .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+           .setNetworkSpecifier(specifier)
+           .build();
+
+       ConnectivityManager connectivityManager = (ConnectivityManager) cordova.getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+       connectivityManager.requestNetwork(request, new ConnectivityManager.NetworkCallback() {
+           @Override
+           public void onAvailable(Network network) {
+               super.onAvailable(network);
+               wifiManager.setWifiEnabled(false);
+
+               callbackContext.success("Connected to Wi-Fi network: " + ssid);
+           }
+
+           @Override
+           public void onUnavailable() {
+               super.onUnavailable();
+               callbackContext.error("Failed to connect to Wi-Fi network");
+           }
+       });
+    }
+
+    private void disconnectFromNetwork(CallbackContext callbackContext) {
+        WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+
+        if (!wifiManager.isWifiEnabled()) {
+            callbackContext.error("Wi-Fi is disabled");
+            return;
+        }
+
+        wifiManager.disconnect();
+        callbackContext.success("Disconnected from Wi-Fi network");
+    }
+}

package/src/android/WifiUtils.java

@@ -0,0 +1,268 @@
+package wifiplugin;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.text.format.Formatter;
+import org.json.JSONObject;
+import org.apache.cordova.PluginResult;
+import org.json.JSONException;
+import java.net.UnknownHostException;
+import java.io.IOException;
+import org.json.JSONArray;
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import android.content.Context;
+import java.net.InetAddress;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import android.net.wifi.ScanResult;
+import java.util.List;
+import java.util.Collections;
+import java.util.Comparator;
+
+
+public class WifiUtils {
+public static void getSignalStrength(Context context, CallbackContext callbackContext) {
+        try {
+            WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
+            WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+            int signalStrength = wifiInfo.getRssi();
+
+            PluginResult result = new PluginResult(PluginResult.Status.OK, signalStrength);
+            callbackContext.sendPluginResult(result);
+        } catch (Exception e) {
+            callbackContext.error("Error getting signal strength: " + e.getMessage());
+        }
+    }
+
+    public static void getWifiStrength(Context context, CallbackContext callbackContext) {
+        try {
+            WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
+            WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+            int wifiStrength = WifiManager.calculateSignalLevel(wifiInfo.getRssi(), 5);
+
+            PluginResult result = new PluginResult(PluginResult.Status.OK, wifiStrength);
+            callbackContext.sendPluginResult(result);
+        } catch (Exception e) {
+            callbackContext.error("Error getting WiFi strength: " + e.getMessage());
+        }
+    }
+
+        public static void getWifiList(CordovaInterface cordova, CallbackContext callbackContext) {
+            WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+
+            if (!wifiManager.isWifiEnabled()) {
+                callbackContext.error("Wi-Fi is disabled");
+                return;
+            }
+
+            wifiManager.startScan();
+            List<ScanResult> scanResults = wifiManager.getScanResults();
+
+            // Sort the scan results by Level in ascending order
+          Collections.sort(scanResults, new Comparator<ScanResult>() {
+              @Override
+              public int compare(ScanResult o1, ScanResult o2) {
+                  // Sort in descending order of signal strength (higher values first)
+                  return Integer.compare(o2.level, o1.level);
+              }
+          });
+
+            JSONArray wifiArray = new JSONArray();
+            for (ScanResult scanResult : scanResults) {
+                JSONObject wifiObject = new JSONObject();
+                try {
+                    wifiObject.put("SSID", scanResult.SSID);
+                    wifiObject.put("BSSID", scanResult.BSSID);
+                    wifiObject.put("capabilities", scanResult.capabilities);
+                    wifiObject.put("frequency", scanResult.frequency / 1000.0 + " GHz"); // Convert frequency to GHz
+                    wifiObject.put("security", getSecurityType(scanResult)); // Get security type
+                           wifiObject.put("level", scanResult.level); // Signal strength in dBm
+ // Manufacturer is not directly available from ScanResult
+                    wifiObject.put("channelWidth", getChannelWidth(scanResult.channelWidth)); // Get channel width
+                    // PHY Mode and PHY Speed capability are not directly available from ScanResult
+wifiObject.put("distance", calculateDistance(scanResult.level, scanResult.frequency)); // Estimate distance
+        wifiObject.put("hasPassword", hasPassword(scanResult.capabilities)); // Determine if network is secured
+
+                    wifiArray.put(wifiObject);
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            PluginResult result = new PluginResult(PluginResult.Status.OK, wifiArray);
+            callbackContext.sendPluginResult(result);
+        }
+
+// Utility method to check if network is secured
+private static boolean hasPassword(String capabilities) {
+    return capabilities.contains("WEP") || capabilities.contains("WPA") ||
+           capabilities.contains("WPA2") || capabilities.contains("WPA3") ||
+           capabilities.contains("PSK");
+}
+        // Utility method to determine security type from capabilities
+        private static String getSecurityType(ScanResult scanResult) {
+            if (scanResult.capabilities.contains("WEP")) {
+                return "WEP";
+            } else if (scanResult.capabilities.contains("WPA")) {
+                return "WPA";
+            } else if (scanResult.capabilities.contains("WPA2")) {
+                return "WPA2";
+            } else if (scanResult.capabilities.contains("WPA3")) {
+                return "WPA3";
+            }
+            return "Open";
+        }
+
+
+        // Utility method to get channel width description
+        private static String getChannelWidth(int channelWidth) {
+            switch (channelWidth) {
+                case ScanResult.CHANNEL_WIDTH_20MHZ:
+                    return "20 MHz";
+                case ScanResult.CHANNEL_WIDTH_40MHZ:
+                    return "40 MHz";
+                case ScanResult.CHANNEL_WIDTH_80MHZ:
+                    return "80 MHz";
+                case ScanResult.CHANNEL_WIDTH_160MHZ:
+                    return "160 MHz";
+                default:
+                    return "Unknown";
+            }
+        }
+
+     // Utility method to estimate distance and format it to 2 decimal places
+     private static String calculateDistance(double signalLevelInDb, double freqInMHz) {
+         double exp = (27.55 - (20 * Math.log10(freqInMHz)) + Math.abs(signalLevelInDb)) / 20.0;
+         double distance = Math.pow(10.0, exp);
+         return String.format("%.2f", distance);
+     }
+
+       private int calculateWifiStrength(WifiManager wifiManager) {
+            int numberOfLevels = 5; // You can adjust this based on your preference
+            WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+            int signalLevel = WifiManager.calculateSignalLevel(wifiInfo.getRssi(), numberOfLevels);
+            return (signalLevel * 100) / numberOfLevels;
+        }
+    public static void getConnectedDevices(Context context,CordovaInterface cordova, CallbackContext callbackContext) {
+        cordova.getThreadPool().execute(() -> {
+            try {
+                JSONArray devicesArray = new JSONArray();
+
+                // Get the current device's IP address
+                WifiManager wifiManager = (WifiManager) cordova.getActivity().getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+                WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+                String ipAddress = Formatter.formatIpAddress(wifiInfo.getIpAddress());
+                String subnet = ipAddress.substring(0, ipAddress.lastIndexOf("."));
+
+                // Perform IP scanning to find connected devices
+                ExecutorService executor = Executors.newFixedThreadPool(20);
+                CountDownLatch latch = new CountDownLatch(255);
+
+                for (int i = 1; i <= 255; i++) {
+                    final int host = i;
+                    executor.submit(() -> {
+                        String ip = subnet + "." + host;
+                        try {
+                            if (InetAddress.getByName(ip).isReachable(100)) {
+                                JSONObject deviceObject = new JSONObject();
+deviceObject.put("ipAddress", ip);
+deviceObject.put("deviceName", getDeviceNameByIp(ip));
+deviceObject.put("localHost", isLocalHost(ip));
+deviceObject.put("loopbackAddress", isLoopbackAddress(ip));
+deviceObject.put("hostAddress", getHostAddress(ip));
+deviceObject.put("canonicalHostName", getCanonicalHostName(ip));
+deviceObject.put("multicastAddress", isMulticastAddress(ip));
+deviceObject.put("siteLocalAddress", isSiteLocalAddress(ip));
+                                devicesArray.put(deviceObject);
+                            }
+                        } catch (UnknownHostException | JSONException e) {
+                            e.printStackTrace();
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        } finally {
+                            latch.countDown();
+                        }
+                    });
+                }
+
+                executor.shutdown();
+
+                // Wait for all threads to finish
+                latch.await();
+
+                PluginResult result = new PluginResult(PluginResult.Status.OK, devicesArray);
+                callbackContext.sendPluginResult(result);
+            } catch (Exception e) {
+                callbackContext.error("Error getting connected devices: " + e.getMessage());
+            }
+        });
+    }
+    private static String getDeviceNameByIp(String ipAddress) {
+        try {
+            InetAddress inetAddress = InetAddress.getByName(ipAddress);
+            return inetAddress.getHostName();
+        }
+         catch (IOException e) {
+            e.printStackTrace();
+             return "Unknown";
+        }
+    }
+
+    private static boolean isLocalHost(String ipAddress) {
+        return InetAddress.getLoopbackAddress().getHostAddress().equals(ipAddress);
+    }
+
+    private static boolean isLoopbackAddress(String ipAddress) {
+        try {
+            return InetAddress.getByName(ipAddress).isLoopbackAddress();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private static String getHostAddress(String ipAddress) {
+        try {
+            return InetAddress.getByName(ipAddress).getHostAddress();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return "Unknown";
+        }
+    }
+
+    private static String getCanonicalHostName(String ipAddress) {
+        try {
+            return InetAddress.getByName(ipAddress).getCanonicalHostName();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return "Unknown";
+        }
+    }
+
+    private static boolean isMulticastAddress(String ipAddress) {
+        try {
+            return InetAddress.getByName(ipAddress).isMulticastAddress();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private static boolean isSiteLocalAddress(String ipAddress) {
+        try {
+            return InetAddress.getByName(ipAddress).isSiteLocalAddress();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+}

package/src/ios/WifiPlugin.h

@@ -0,0 +1,21 @@
+#import <Cordova/CDVPlugin.h>
+
+@interface WifiPlugin : CDVPlugin
+
+- (void)getWifiList:(CDVInvokedUrlCommand*)command;
+- (void)connectToNetwork:(CDVInvokedUrlCommand*)command;
+- (void)disconnectFromNetwork:(CDVInvokedUrlCommand*)command;
+- (void)isWifiEnabled:(CDVInvokedUrlCommand*)command;
+- (void)wifiToggle:(CDVInvokedUrlCommand*)command;
+- (void)isConnectedToInternet:(CDVInvokedUrlCommand*)command;
+- (void)checkAndRequestWifiPermission:(CDVInvokedUrlCommand*)command;
+- (void)getConnectedDevices:(CDVInvokedUrlCommand*)command;
+- (void)getWifiStrength:(CDVInvokedUrlCommand*)command;
+- (void)getSignalStrength:(CDVInvokedUrlCommand*)command;
+- (void)ping:(CDVInvokedUrlCommand*)command;
+- (void)getIpInfo:(CDVInvokedUrlCommand*)command;
+- (void)getAllWifiDetails:(CDVInvokedUrlCommand*)command;
+- (void)canConnectToInternet:(CDVInvokedUrlCommand*)command;
+- (void)canConnectToRouter:(CDVInvokedUrlCommand*)command;
+
+@end