@pietro-fe01/nativescript-connectivity-manager-plugin 0.1.0 → 1.0.0

package/README.md

@@ -1,126 +1,126 @@
-# NativeScript ConnectivityManager Plugin
-
-A plugin to manage the device connectivity on Android and iOS.
-
-- [x] Android
-  - [x] WiFi
-  - [x] Cellular
-  - [x] GPS
-  - [ ] Bluetooth
-  - [ ] Grant permissions
-- [x] iOS
-  - [x] WiFi
-    - [x] Connect to wifi
-    - [x] Get SSID
-    - [] Others not implemented yet
-  - [ ] Cellular
-  - [ ] GPS
-  - [ ] Bluetooth
-
-## Installation
-
-`tns plugin add nativescript-connectivity-manager-plugin`
-
-## Demo
-
-Check out the [Angular demo app](https://github.com/1IoT/nativescript-connectivity-manager-plugin/blob/master/demo-angular/src/app/home/home.component.ts)
-and run it locally:
-
-```
-git clone https://github.com/1IoT/nativescript-connectivity-manager-plugin
-cd nativescript-connectivity-manager-plugin/src
-npm run demo:android
-```
-
-## Usage
-
-```
-import {ConnectivityManagerImpl} from 'nativescript-connectivity-manager-plugin';
-
-@Component({
-    selector: "Home",
-    templateUrl: "./home.component.html"
-})
-export class HomeComponent implements OnInit {
-
-    private static NETWORK_SSID: string = "MY_SSID";
-    private static NETWORK_PASSPHARSE: string = "MY_KEY";
-    private static CONNECTION_TIMEOUT_MS: number = 30000;
-    private static DISCONNECT_TIMEOUT_MS: number = 15000;
-
-    constructor(private connectivityManager: ConnectivityManagerImpl, private httpClient: HttpClient) {
-    }
-
-    ngOnInit(): void {
-    }
-
-    public async getInfos(): Promise<void> {
-        const ssid = await this.connectivityManager.getSSIDAsync();
-        console.log("Wifi SSID: " + ssid);
-        console.log("NetworkId: " + this.connectivityManager.getWifiNetworkId());
-        console.log("Wifi enabled: " + this.connectivityManager.isWifiEnabled());
-        console.log("Wifi connected: " + this.connectivityManager.isWifiConnected());
-        console.log("Cellular enabled: " + this.connectivityManager.isCellularEnabled());
-        console.log("Cellular connected: " + this.connectivityManager.isCellularConnected());
-        console.log("GPS enabled: " + this.connectivityManager.isGpsEnabled());
-        console.log("GPS connected: " + this.connectivityManager.isGpsConnected());
-    }
-
-    public scan(): void {
-        console.log("Start scan...");
-        this.connectivityManager.scanWifiNetworks().then((wifiSSIDs: string[]) => {
-            console.log(wifiSSIDs);
-        });
-    }
-
-    public async connect(): Promise<boolean> {
-        console.log("Start connection...");
-        console.log("Disconnect with the source network...");
-        return this.connectivityManager.connectToWifiNetwork(HomeComponent.NETWORK_SSID, HomeComponent.NETWORK_PASSPHARSE, HomeComponent.CONNECTION_TIMEOUT_MS);
-    }
-
-    public async disconnect(): Promise<boolean> {
-        return this.connectivityManager.disconnectWifiNetwork(HomeComponent.DISCONNECT_TIMEOUT_MS);
-    }
-}
-
-```
-
-## API
-
-Requires **Android SDK**: 29
-
-**WARNING: Note that even for scanning WiFi and retrieving the SSID, location permission must be given and GPS must be enabled!**
-
-### iOS / iPadOS SSID Notes
-
-- `getSSID()` is a legacy synchronous best-effort API and may return `null` on newer iOS/iPadOS versions when only CaptiveNetwork APIs are used.
-- Use `getSSIDAsync()` on iOS/iPadOS 14+ (including iOS/iPadOS 26+) because it uses `NEHotspotNetwork.fetchCurrentWithCompletionHandler`.
-- To retrieve the SSID on iOS, apps must include the **Access Wi-Fi Information** entitlement (`com.apple.developer.networking.wifi-info`) and satisfy at least one Apple runtime condition (for example: the app configured the current network via `NEHotspotConfiguration`, or the app has CoreLocation authorization with precise location).
-
-| Method                                                                           | Return              | Description                                          |
-| -------------------------------------------------------------------------------- | ------------------- | ---------------------------------------------------- |
-| getSSID()                                                                        | string              | legacy synchronous best-effort SSID read             |
-| async getSSIDAsync()                                                             | Promise\<string \| null\> | recommended SSID API, especially on iOS/iPadOS 14+ |
-| getWifiNetworkId()                                                               | number              |
-| isWifiEnabled()                                                                  | boolean             |
-| isWifiConnected()                                                                | boolean             |
-| isCellularEnabled()                                                              | boolean             |
-| isCellularConnected()                                                            | boolean             |
-| isGpsEnabled()                                                                   | boolean             |
-| isGpsConnected()                                                                 | boolean             |
-| hasInternet()                                                                    | boolean             |
-| async scanWifiNetworks()                                                         | Promise\<string[]\> | requires granted location permission and enabled gps |
-| async connectToWifiNetwork(ssid: string, password: string, milliseconds: number) | Promise\<boolean\>  |
-| async disconnectWifiNetwork(timeoutMs: number)                                   | Promise\<boolean\>  |
-
-To grant permissions (location permissions) please use the [nativescript-advanced-permissions plugin](https://market.nativescript.org/plugins/nativescript-advanced-permissions/) or implement another mechanism. IMHO, dealing with permissions should not be done on plugin level but on application level instead.
-
-## Tips
-
-- Docs about the [tns-platform-declarations](https://github.com/NativeScript/NativeScript/tree/master/tns-platform-declarations)
-- If the project cannot be build, maybe `npm run demo:reset` and `npm run build` can fix it
-
-## License
-
-Apache License Version 2.0, January 2004
+# NativeScript ConnectivityManager Plugin
+
+A plugin to manage the device connectivity on Android and iOS.
+
+- [x] Android
+  - [x] WiFi
+  - [x] Cellular
+  - [x] GPS
+  - [ ] Bluetooth
+  - [ ] Grant permissions
+- [x] iOS
+  - [x] WiFi
+    - [x] Connect to wifi
+    - [x] Get SSID
+    - [] Others not implemented yet
+  - [ ] Cellular
+  - [ ] GPS
+  - [ ] Bluetooth
+
+## Installation
+
+`tns plugin add nativescript-connectivity-manager-plugin`
+
+## Demo
+
+Check out the [Angular demo app](https://github.com/1IoT/nativescript-connectivity-manager-plugin/blob/master/demo-angular/src/app/home/home.component.ts)
+and run it locally:
+
+```
+git clone https://github.com/1IoT/nativescript-connectivity-manager-plugin
+cd nativescript-connectivity-manager-plugin/src
+npm run demo:android
+```
+
+## Usage
+
+```
+import {ConnectivityManagerImpl} from 'nativescript-connectivity-manager-plugin';
+
+@Component({
+    selector: "Home",
+    templateUrl: "./home.component.html"
+})
+export class HomeComponent implements OnInit {
+
+    private static NETWORK_SSID: string = "MY_SSID";
+    private static NETWORK_PASSPHARSE: string = "MY_KEY";
+    private static CONNECTION_TIMEOUT_MS: number = 30000;
+    private static DISCONNECT_TIMEOUT_MS: number = 15000;
+
+    constructor(private connectivityManager: ConnectivityManagerImpl, private httpClient: HttpClient) {
+    }
+
+    ngOnInit(): void {
+    }
+
+    public async getInfos(): Promise<void> {
+        const ssid = await this.connectivityManager.getSSIDAsync();
+        console.log("Wifi SSID: " + ssid);
+        console.log("NetworkId: " + this.connectivityManager.getWifiNetworkId());
+        console.log("Wifi enabled: " + this.connectivityManager.isWifiEnabled());
+        console.log("Wifi connected: " + this.connectivityManager.isWifiConnected());
+        console.log("Cellular enabled: " + this.connectivityManager.isCellularEnabled());
+        console.log("Cellular connected: " + this.connectivityManager.isCellularConnected());
+        console.log("GPS enabled: " + this.connectivityManager.isGpsEnabled());
+        console.log("GPS connected: " + this.connectivityManager.isGpsConnected());
+    }
+
+    public scan(): void {
+        console.log("Start scan...");
+        this.connectivityManager.scanWifiNetworks().then((wifiSSIDs: string[]) => {
+            console.log(wifiSSIDs);
+        });
+    }
+
+    public async connect(): Promise<boolean> {
+        console.log("Start connection...");
+        console.log("Disconnect with the source network...");
+        return this.connectivityManager.connectToWifiNetwork(HomeComponent.NETWORK_SSID, HomeComponent.NETWORK_PASSPHARSE, HomeComponent.CONNECTION_TIMEOUT_MS);
+    }
+
+    public async disconnect(): Promise<boolean> {
+        return this.connectivityManager.disconnectWifiNetwork(HomeComponent.DISCONNECT_TIMEOUT_MS);
+    }
+}
+
+```
+
+## API
+
+Requires **Android SDK**: 29
+
+**WARNING: Note that even for scanning WiFi and retrieving the SSID, location permission must be given and GPS must be enabled!**
+
+### iOS / iPadOS SSID Notes
+
+- `getSSID()` is a legacy synchronous best-effort API and may return `null` on newer iOS/iPadOS versions when only CaptiveNetwork APIs are used.
+- Use `getSSIDAsync()` on iOS/iPadOS 14+ (including iOS/iPadOS 26+) because it uses `NEHotspotNetwork.fetchCurrentWithCompletionHandler`.
+- To retrieve the SSID on iOS, apps must include the **Access Wi-Fi Information** entitlement (`com.apple.developer.networking.wifi-info`) and satisfy at least one Apple runtime condition (for example: the app configured the current network via `NEHotspotConfiguration`, or the app has CoreLocation authorization with precise location).
+
+| Method                                                                           | Return              | Description                                          |
+| -------------------------------------------------------------------------------- | ------------------- | ---------------------------------------------------- |
+| getSSID()                                                                        | string              | legacy synchronous best-effort SSID read             |
+| async getSSIDAsync()                                                             | Promise\<string \| null\> | recommended SSID API, especially on iOS/iPadOS 14+ |
+| getWifiNetworkId()                                                               | number              |
+| isWifiEnabled()                                                                  | boolean             |
+| isWifiConnected()                                                                | boolean             |
+| isCellularEnabled()                                                              | boolean             |
+| isCellularConnected()                                                            | boolean             |
+| isGpsEnabled()                                                                   | boolean             |
+| isGpsConnected()                                                                 | boolean             |
+| hasInternet()                                                                    | boolean             |
+| async scanWifiNetworks()                                                         | Promise\<string[]\> | requires granted location permission and enabled gps |
+| async connectToWifiNetwork(ssid: string, password: string, milliseconds: number) | Promise\<boolean\>  |
+| async disconnectWifiNetwork(timeoutMs: number)                                   | Promise\<boolean\>  |
+
+To grant permissions (location permissions) please use the [nativescript-advanced-permissions plugin](https://market.nativescript.org/plugins/nativescript-advanced-permissions/) or implement another mechanism. IMHO, dealing with permissions should not be done on plugin level but on application level instead.
+
+## Tips
+
+- Docs about the [tns-platform-declarations](https://github.com/NativeScript/NativeScript/tree/master/tns-platform-declarations)
+- If the project cannot be build, maybe `npm run demo:reset` and `npm run build` can fix it
+
+## License
+
+Apache License Version 2.0, January 2004

package/connectivity-manager-impl.android.d.ts

@@ -0,0 +1,36 @@
+import { Common } from "./connectivity-manager-impl.common";
+import { ConnectivityManagerInterface } from "./connectivity-manager-interface";
+export declare class ConnectivityManagerImpl extends Common implements ConnectivityManagerInterface {
+    private readonly WIFI_SSID_BLACKLIST;
+    private readonly wifiManager;
+    private readonly cellularManager;
+    private readonly locationManager;
+    private readonly connectivityManager;
+    private forcedNetworkCallback;
+    private previousConnectionMetered;
+    private previousConnectionWiFi;
+    private previousSsid;
+    private connectResolve;
+    private disconnectResolve;
+    private safeUnregisterNetworkCallback;
+    private static getCapabilities;
+    getSSID(): string;
+    getSSIDAsync(): Promise<string | null>;
+    getWifiNetworkId(): number;
+    isWifiEnabled(): boolean;
+    isWifiConnected(): boolean;
+    isCellularEnabled(): boolean;
+    isCellularConnected(): boolean;
+    isGpsEnabled(): boolean;
+    isGpsConnected(): boolean;
+    scanWifiNetworks(): Promise<string[]>;
+    connectToWifiNetwork(ssid: string, password: string, milliseconds: number): Promise<boolean>;
+    hasInternet(): boolean;
+    private static hasInternet;
+    disconnectWifiNetwork(timeoutMs: number): Promise<boolean>;
+    private static isPreviousOrStableNetwork;
+    private static logConnectivityInfo;
+    private static getInterfaceName;
+    private waitUntilConnectedToWifi;
+    private disconnectWifiAndRemoveNetwork;
+}

package/connectivity-manager-impl.android.js

@@ -0,0 +1,339 @@
+import { Common } from "./connectivity-manager-impl.common";
+import * as application from "@nativescript/core/application";
+var Context = android.content.Context;
+var WifiConfiguration = android.net.wifi.WifiConfiguration;
+var ConnectivityManagerService = android.net.ConnectivityManager;
+var WifiManagerService = android.net.wifi.WifiManager;
+var LocationManagerService = android.location.LocationManager;
+var NetworkRequest = android.net.NetworkRequest;
+var NetworkCapabilities = android.net.NetworkCapabilities;
+var WifiNetworkSpecifier = android.net.wifi.WifiNetworkSpecifier;
+let IS_Q_VERSION = false;
+try {
+    IS_Q_VERSION =
+        android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q;
+}
+catch (_a) {
+    IS_Q_VERSION = false;
+}
+export class ConnectivityManagerImpl extends Common {
+    constructor() {
+        super(...arguments);
+        this.WIFI_SSID_BLACKLIST = ["", " "];
+        this.wifiManager = application.android.context.getSystemService(Context.WIFI_SERVICE);
+        this.cellularManager = application.android.context.getSystemService(Context.TELEPHONY_SERVICE);
+        this.locationManager = application.android.context.getSystemService(Context.LOCATION_SERVICE);
+        this.connectivityManager = application.android.context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        this.previousConnectionMetered = false;
+        this.previousConnectionWiFi = false;
+        this.previousSsid = undefined;
+        this.connectResolve = null;
+        this.disconnectResolve = null;
+    }
+    safeUnregisterNetworkCallback(callback) {
+        if (!callback) {
+            return;
+        }
+        try {
+            this.connectivityManager.unregisterNetworkCallback(callback);
+        }
+        catch (_) {
+        }
+    }
+    static getCapabilities(connectivityManager, network) {
+        if (!network) {
+            return null;
+        }
+        return connectivityManager.getNetworkCapabilities(network);
+    }
+    getSSID() {
+        return this.wifiManager.getConnectionInfo().getSSID();
+    }
+    getSSIDAsync() {
+        return Promise.resolve(this.getSSID());
+    }
+    getWifiNetworkId() {
+        return this.wifiManager.getConnectionInfo().getNetworkId();
+    }
+    isWifiEnabled() {
+        return this.wifiManager.isWifiEnabled();
+    }
+    isWifiConnected() {
+        if (!this.isWifiEnabled()) {
+            throw new Error("Wifi is not enabled.");
+        }
+        if (IS_Q_VERSION) {
+            return (this.connectivityManager.getNetworkCapabilities(this.connectivityManager.getActiveNetwork()) &&
+                this.connectivityManager
+                    .getNetworkCapabilities(this.connectivityManager.getActiveNetwork())
+                    .hasTransport(NetworkCapabilities.TRANSPORT_WIFI));
+        }
+        else {
+            return this.connectivityManager
+                .getNetworkInfo(ConnectivityManagerService.TYPE_WIFI)
+                .isConnected();
+        }
+    }
+    isCellularEnabled() {
+        return this.cellularManager.isDataEnabled();
+    }
+    isCellularConnected() {
+        if (!this.isCellularEnabled()) {
+            throw new Error("Cellular is not enabled.");
+        }
+        const capabilities = ConnectivityManagerImpl.getCapabilities(this.connectivityManager, this.connectivityManager.getActiveNetwork());
+        return capabilities
+            ? capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
+            : false;
+    }
+    isGpsEnabled() {
+        return this.locationManager.isProviderEnabled(LocationManagerService.GPS_PROVIDER);
+    }
+    isGpsConnected() {
+        return this.locationManager.isProviderEnabled(LocationManagerService.NETWORK_PROVIDER);
+    }
+    async scanWifiNetworks() {
+        return new Promise((resolve) => {
+            application.android.registerBroadcastReceiver(WifiManagerService.SCAN_RESULTS_AVAILABLE_ACTION, () => {
+                application.android.unregisterBroadcastReceiver(WifiManagerService.SCAN_RESULTS_AVAILABLE_ACTION);
+                let wifiSsidList = [];
+                let wifiScanResult = this.wifiManager.getScanResults();
+                for (let i = 0; i < wifiScanResult.size(); i++) {
+                    let wifi = wifiScanResult.get(i);
+                    if (wifiSsidList.indexOf(wifi.SSID) == -1 &&
+                        this.WIFI_SSID_BLACKLIST.indexOf(wifi.SSID) == -1) {
+                        wifiSsidList.push(wifi.SSID);
+                    }
+                }
+                resolve(wifiSsidList);
+            });
+            this.wifiManager.startScan();
+        });
+    }
+    async connectToWifiNetwork(ssid, password, milliseconds) {
+        return new Promise((resolve) => {
+            const safeTimeoutMs = Math.max(0, Number(milliseconds) || 0);
+            let completed = false;
+            let connectTimeout = null;
+            const complete = (result) => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                if (connectTimeout) {
+                    clearTimeout(connectTimeout);
+                    connectTimeout = null;
+                }
+                resolve(result);
+            };
+            if (!this.isWifiEnabled()) {
+                complete(false);
+                return;
+            }
+            try {
+                const that = this;
+                this.previousConnectionMetered = this.connectivityManager.isActiveNetworkMetered();
+                if (this.isWifiConnected()) {
+                    this.previousConnectionWiFi = true;
+                    this.previousSsid = this.getSSID();
+                }
+                else {
+                    this.previousConnectionWiFi = false;
+                    this.previousSsid = undefined;
+                }
+                this.connectResolve = complete;
+                connectTimeout = setTimeout(() => {
+                    this.safeUnregisterNetworkCallback(this.forcedNetworkCallback);
+                    complete(false);
+                }, safeTimeoutMs);
+                if (IS_Q_VERSION) {
+                    let wifiNetworkSpecifier = new WifiNetworkSpecifier.Builder()
+                        .setSsid(ssid)
+                        .setWpa2Passphrase(password)
+                        .build();
+                    let networkRequest = new NetworkRequest.Builder()
+                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+                        .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                        .setNetworkSpecifier(wifiNetworkSpecifier)
+                        .build();
+                    this.forcedNetworkCallback = new (ConnectivityManagerService.NetworkCallback.extend({
+                        onAvailable: function (network) {
+                            console.log("Connected to the network");
+                            that.connectivityManager.bindProcessToNetwork(network);
+                            that.connectResolve(true);
+                        },
+                        onUnavailable: function () {
+                            this.super.onUnavailable();
+                            that.connectResolve(false);
+                            that.safeUnregisterNetworkCallback(that.forcedNetworkCallback);
+                        },
+                    }))();
+                    console.log("Connecting to the network...");
+                    this.connectivityManager.requestNetwork(networkRequest, this.forcedNetworkCallback, milliseconds);
+                }
+                else {
+                    const ssidFormatted = `"${ssid}"`;
+                    let conf = new WifiConfiguration();
+                    conf.SSID = ssidFormatted;
+                    if (password) {
+                        conf.preSharedKey = '"' + password + '"';
+                        conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+                    }
+                    else {
+                        conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+                    }
+                    let networkRequest = new NetworkRequest.Builder()
+                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+                        .build();
+                    this.forcedNetworkCallback = new (ConnectivityManagerService.NetworkCallback.extend({
+                        onAvailable: function (network) {
+                            if (that.getSSID() == ssidFormatted) {
+                                console.log("Connected to the network");
+                                that.connectivityManager.bindProcessToNetwork(network);
+                                that.connectivityManager.unregisterNetworkCallback(this);
+                                that.connectResolve(true);
+                            }
+                        },
+                        onUnavailable: function () {
+                            this.super.onUnavailable();
+                        },
+                    }))();
+                    this.connectivityManager.registerNetworkCallback(networkRequest, this.forcedNetworkCallback);
+                    const list = this.wifiManager.getConfiguredNetworks();
+                    let netId = -1;
+                    for (let i = 0; i < list.size(); i++) {
+                        const network = list.get(i);
+                        if (network.SSID === ssidFormatted) {
+                            netId = network.networkId;
+                            break;
+                        }
+                    }
+                    if (netId == -1) {
+                        netId = this.wifiManager.addNetwork(conf);
+                    }
+                    this.wifiManager.enableNetwork(netId, true);
+                }
+            }
+            catch (error) {
+                console.log("Something went wrong while connecting to the Wi-Fi. " + error);
+                complete(false);
+            }
+        });
+    }
+    hasInternet() {
+        return ConnectivityManagerImpl.hasInternet(this.connectivityManager, this.connectivityManager.getActiveNetwork());
+    }
+    static hasInternet(connectivityManager, network) {
+        const capabilities = ConnectivityManagerImpl.getCapabilities(connectivityManager, network);
+        return capabilities
+            ? capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            : false;
+    }
+    async disconnectWifiNetwork(timeoutMs) {
+        return new Promise((resolve) => {
+            let that = this;
+            let networkConnectivity = null;
+            let completed = false;
+            const complete = (result) => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                clearTimeout(promiseTimeout);
+                that.safeUnregisterNetworkCallback(networkConnectivity);
+                resolve(result);
+            };
+            this.disconnectResolve = complete;
+            let promiseTimeout = setTimeout(() => {
+                console.log("Ran into timeout when disconnecting and fetching new connection.");
+                complete(false);
+            }, timeoutMs);
+            if (IS_Q_VERSION) {
+                networkConnectivity = new (ConnectivityManagerService.NetworkCallback.extend({
+                    onAvailable: function (network) {
+                        ConnectivityManagerImpl.logConnectivityInfo(that.wifiManager, that.connectivityManager, network);
+                        if (ConnectivityManagerImpl.isPreviousOrStableNetwork(that.wifiManager, that.connectivityManager, network, that.previousConnectionMetered, that.previousConnectionWiFi, that.previousSsid)) {
+                            that.connectivityManager.bindProcessToNetwork(network);
+                            that.disconnectResolve(true);
+                        }
+                    },
+                    onLost: function (network) {
+                        console.log("Disconnected.");
+                    },
+                }))();
+                this.connectivityManager.registerNetworkCallback(new NetworkRequest.Builder().build(), networkConnectivity);
+                this.safeUnregisterNetworkCallback(this.forcedNetworkCallback);
+            }
+            else {
+                this.wifiManager.disableNetwork(this.wifiManager.getConnectionInfo().getNetworkId());
+                complete(true);
+            }
+        });
+    }
+    static isPreviousOrStableNetwork(wifiManager, connectivityManager, network, previousNetworkMetered, previousNetworkWiFi, previousNetworkSsid) {
+        const networkCapabilities = ConnectivityManagerImpl.getCapabilities(connectivityManager, network);
+        let isWifi = networkCapabilities
+            ? networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+            : false;
+        if (previousNetworkWiFi && isWifi) {
+            let ssid = wifiManager.getConnectionInfo().getSSID();
+            return ssid == previousNetworkSsid;
+        }
+        else if (previousNetworkWiFi) {
+            return false;
+        }
+        if (!networkCapabilities) {
+            return false;
+        }
+        let meteredNow = !networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+        let hasInternet = ConnectivityManagerImpl.hasInternet(connectivityManager, network);
+        return meteredNow == previousNetworkMetered && hasInternet;
+    }
+    static logConnectivityInfo(wifiManager, connectivityManager, network) {
+        let activeNetwork = connectivityManager.getActiveNetwork();
+        let defaultActive = connectivityManager.isDefaultNetworkActive();
+        let boundNetwork = connectivityManager.getBoundNetworkForProcess();
+        let allNetworks = connectivityManager.getAllNetworks();
+        let ssid = wifiManager.getConnectionInfo().getSSID();
+        console.log("Connected via " +
+            ConnectivityManagerImpl.getInterfaceName(connectivityManager, network));
+        console.log("New network: " + network);
+        console.log("Active network: " + activeNetwork);
+        console.log("Active network adapter: " +
+            ConnectivityManagerImpl.getInterfaceName(connectivityManager, activeNetwork));
+        console.log("Default is active?: " + defaultActive);
+        console.log("Current bound network: " + boundNetwork);
+        console.log("Current bound network adapter: " +
+            ConnectivityManagerImpl.getInterfaceName(connectivityManager, boundNetwork));
+        console.log("All networks: " + allNetworks);
+        console.log("Current SSID:" + ssid);
+    }
+    static getInterfaceName(connectivityManager, activeNetwork) {
+        let linkProperties = connectivityManager.getLinkProperties(activeNetwork);
+        if (linkProperties == null) {
+            return "";
+        }
+        return linkProperties.getInterfaceName();
+    }
+    async waitUntilConnectedToWifi(milliseconds) {
+        return new Promise((resolve) => {
+            let intervalTimer = setInterval(() => {
+                if (this.isWifiConnected()) {
+                    clearInterval(intervalTimer);
+                    clearTimeout(timeout);
+                    resolve(true);
+                }
+            }, 500);
+            let timeout = setTimeout(() => {
+                clearInterval(intervalTimer);
+                this.disconnectWifiAndRemoveNetwork();
+                throw new Error("Could not connect in the allowed time.");
+            }, milliseconds);
+        });
+    }
+    disconnectWifiAndRemoveNetwork() {
+        this.wifiManager.removeNetwork(this.getWifiNetworkId());
+        this.wifiManager.disconnect();
+    }
+}
+//# sourceMappingURL=connectivity-manager-impl.android.js.map

package/connectivity-manager-impl.common.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from "@nativescript/core/data/observable";
+export declare class Common extends Observable {
+    constructor();
+}

package/connectivity-manager-impl.common.js

@@ -0,0 +1,7 @@
+import { Observable } from "@nativescript/core/data/observable";
+export class Common extends Observable {
+    constructor() {
+        super();
+    }
+}
+//# sourceMappingURL=connectivity-manager-impl.common.js.map