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

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

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

@@ -0,0 +1,40 @@
+import { Common } from "./connectivity-manager-impl.common";
+import { ConnectivityManagerInterface } from "./connectivity-manager-interface";
+export declare class ConnectivityManagerImpl extends Common implements ConnectivityManagerInterface {
+    private static readonly POLL_INTERVAL_MS;
+    private static readonly SSID_FETCH_TIMEOUT_MS;
+    private static readonly HOTSPOT_ERROR_PENDING;
+    private static readonly HOTSPOT_ERROR_JOIN_ONCE_NOT_SUPPORTED;
+    private static readonly HOTSPOT_ERROR_ALREADY_ASSOCIATED;
+    private previousSsid;
+    private cachedSsid;
+    private ssidRefreshInFlight;
+    private getNetworkInfo;
+    private normalizeSsid;
+    private getSsidFromCaptiveNetwork;
+    private getSsidFromCaptiveNetworkSafe;
+    private getSsidFromHotspotNetwork;
+    private getHotspotErrorCode;
+    private isRecoverableHotspotConfigurationError;
+    private canRetryWithoutJoinOnce;
+    private logHotspotConfigurationError;
+    private createHotspotConfiguration;
+    private applyHotspotConfiguration;
+    private applyHotspotConfigurationWithFallback;
+    private fetchCurrentSsid;
+    private waitUntil;
+    private refreshCachedSsidInBackground;
+    getSSID(): string;
+    getSSIDAsync(): Promise<string | null>;
+    getWifiNetworkId(): number;
+    isWifiEnabled(): boolean;
+    isWifiConnected(): boolean;
+    isCellularEnabled(): boolean;
+    isCellularConnected(): boolean;
+    isGpsEnabled(): boolean;
+    isGpsConnected(): boolean;
+    hasInternet(): boolean;
+    scanWifiNetworks(): Promise<string[]>;
+    connectToWifiNetwork(ssid: string, password: string, milliseconds: number): Promise<boolean>;
+    disconnectWifiNetwork(timeoutMs: number): Promise<boolean>;
+}

package/connectivity-manager-impl.ios.js

@@ -0,0 +1,313 @@
+import { Common } from "./connectivity-manager-impl.common";
+export class ConnectivityManagerImpl extends Common {
+    constructor() {
+        super(...arguments);
+        this.previousSsid = undefined;
+        this.cachedSsid = null;
+        this.ssidRefreshInFlight = null;
+    }
+    getNetworkInfo() {
+        try {
+            let interfaceNames = CNCopySupportedInterfaces();
+            if (!interfaceNames) {
+                return null;
+            }
+            for (let i = 0; i < interfaceNames.count; i++) {
+                let info = (CNCopyCurrentNetworkInfo(interfaceNames[i]));
+                if (!info) {
+                    continue;
+                }
+                let ssid = info.valueForKey(kCNNetworkInfoKeySSID);
+                if (!ssid) {
+                    continue;
+                }
+                return info;
+            }
+            return null;
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    normalizeSsid(rawSsid) {
+        if (rawSsid === null || rawSsid === undefined) {
+            return null;
+        }
+        const normalized = `${rawSsid}`.trim();
+        if (!normalized || normalized === "<unknown ssid>") {
+            return null;
+        }
+        if (normalized.length >= 2 &&
+            normalized.startsWith('"') &&
+            normalized.endsWith('"')) {
+            return normalized.substring(1, normalized.length - 1);
+        }
+        return normalized;
+    }
+    getSsidFromCaptiveNetwork() {
+        const info = this.getNetworkInfo();
+        const ssid = info ? info.valueForKey(kCNNetworkInfoKeySSID) : null;
+        return this.normalizeSsid(ssid);
+    }
+    getSsidFromCaptiveNetworkSafe() {
+        try {
+            return this.getSsidFromCaptiveNetwork();
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    getSsidFromHotspotNetwork(network) {
+        var _a, _b;
+        if (!network) {
+            return null;
+        }
+        return this.normalizeSsid((_b = (_a = network.SSID) !== null && _a !== void 0 ? _a : network.ssid) !== null && _b !== void 0 ? _b : null);
+    }
+    getHotspotErrorCode(err) {
+        return err ? Number(err.code) : -1;
+    }
+    isRecoverableHotspotConfigurationError(err) {
+        const code = this.getHotspotErrorCode(err);
+        return (code === ConnectivityManagerImpl.HOTSPOT_ERROR_ALREADY_ASSOCIATED ||
+            code === ConnectivityManagerImpl.HOTSPOT_ERROR_PENDING);
+    }
+    canRetryWithoutJoinOnce(err) {
+        const code = this.getHotspotErrorCode(err);
+        return (code === ConnectivityManagerImpl.HOTSPOT_ERROR_JOIN_ONCE_NOT_SUPPORTED);
+    }
+    logHotspotConfigurationError(err) {
+        if (!err) {
+            return;
+        }
+        console.log("NEHotspotConfiguration error. domain=" +
+            err.domain +
+            ", code=" +
+            err.code +
+            ", message=" +
+            err.localizedDescription);
+    }
+    createHotspotConfiguration(ssid, password, joinOnce) {
+        const hotspot = NEHotspotConfiguration.new();
+        const configuration = password
+            ? hotspot.initWithSSIDPassphraseIsWEP(ssid, password, false)
+            : hotspot.initWithSSID(ssid);
+        configuration.joinOnce = joinOnce;
+        return configuration;
+    }
+    applyHotspotConfiguration(configuration) {
+        return new Promise((resolve) => {
+            NEHotspotConfigurationManager.sharedManager.applyConfigurationCompletionHandler(configuration, (err) => {
+                resolve(err && err instanceof NSError ? err : null);
+            });
+        });
+    }
+    async applyHotspotConfigurationWithFallback(ssid, password) {
+        const initialConfiguration = this.createHotspotConfiguration(ssid, password, true);
+        const initialError = await this.applyHotspotConfiguration(initialConfiguration);
+        if (!initialError || this.isRecoverableHotspotConfigurationError(initialError)) {
+            return initialError;
+        }
+        if (!this.canRetryWithoutJoinOnce(initialError)) {
+            return initialError;
+        }
+        const fallbackConfiguration = this.createHotspotConfiguration(ssid, password, false);
+        return this.applyHotspotConfiguration(fallbackConfiguration);
+    }
+    fetchCurrentSsid() {
+        return new Promise((resolve) => {
+            let settled = false;
+            let timeoutHandle = setTimeout(() => {
+                finish(this.getSsidFromCaptiveNetworkSafe());
+            }, ConnectivityManagerImpl.SSID_FETCH_TIMEOUT_MS);
+            const finish = (ssid) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeoutHandle);
+                resolve(ssid);
+            };
+            const finishWithFallback = () => {
+                finish(this.getSsidFromCaptiveNetworkSafe());
+            };
+            try {
+                const hotspotNetwork = NEHotspotNetwork;
+                if (hotspotNetwork &&
+                    typeof hotspotNetwork.fetchCurrentWithCompletionHandler === "function") {
+                    hotspotNetwork.fetchCurrentWithCompletionHandler((network) => {
+                        const ssid = this.getSsidFromHotspotNetwork(network);
+                        if (ssid) {
+                            finish(ssid);
+                            return;
+                        }
+                        finishWithFallback();
+                    });
+                    return;
+                }
+            }
+            catch (_) {
+            }
+            finishWithFallback();
+        });
+    }
+    waitUntil(checkFn, timeoutMs, intervalMs = 200) {
+        return new Promise((resolve) => {
+            const safeTimeoutMs = Math.max(0, Number(timeoutMs) || 0);
+            const safeIntervalMs = Math.max(50, Number(intervalMs) || 200);
+            const startedAt = Date.now();
+            let done = false;
+            const finish = (result) => {
+                if (done) {
+                    return;
+                }
+                done = true;
+                resolve(result);
+            };
+            const loop = () => {
+                if (done) {
+                    return;
+                }
+                Promise.resolve()
+                    .then(() => checkFn())
+                    .then((result) => {
+                    if (result) {
+                        finish(true);
+                        return;
+                    }
+                    if (Date.now() - startedAt >= safeTimeoutMs) {
+                        finish(false);
+                        return;
+                    }
+                    setTimeout(loop, safeIntervalMs);
+                })
+                    .catch(() => {
+                    if (Date.now() - startedAt >= safeTimeoutMs) {
+                        finish(false);
+                        return;
+                    }
+                    setTimeout(loop, safeIntervalMs);
+                });
+            };
+            loop();
+        });
+    }
+    refreshCachedSsidInBackground() {
+        if (this.ssidRefreshInFlight) {
+            return;
+        }
+        this.ssidRefreshInFlight = this.fetchCurrentSsid().then((ssid) => {
+            this.cachedSsid = ssid;
+            this.ssidRefreshInFlight = null;
+            return ssid;
+        }, () => {
+            this.ssidRefreshInFlight = null;
+            return this.cachedSsid;
+        });
+    }
+    getSSID() {
+        this.refreshCachedSsidInBackground();
+        if (this.cachedSsid) {
+            return this.cachedSsid;
+        }
+        const fallbackSsid = this.getSsidFromCaptiveNetwork();
+        this.cachedSsid = fallbackSsid;
+        return fallbackSsid;
+    }
+    getSSIDAsync() {
+        return this.fetchCurrentSsid().then((ssid) => {
+            this.cachedSsid = ssid;
+            return ssid;
+        });
+    }
+    getWifiNetworkId() {
+        const info = this.getNetworkInfo();
+        return info ? info.valueForKey(kCNNetworkInfoKeyBSSID) : null;
+    }
+    isWifiEnabled() {
+        return undefined;
+    }
+    isWifiConnected() {
+        return undefined;
+    }
+    isCellularEnabled() {
+        return undefined;
+    }
+    isCellularConnected() {
+        return undefined;
+    }
+    isGpsEnabled() {
+        return undefined;
+    }
+    isGpsConnected() {
+        return undefined;
+    }
+    hasInternet() {
+        return undefined;
+    }
+    scanWifiNetworks() {
+        return undefined;
+    }
+    connectToWifiNetwork(ssid, password, milliseconds) {
+        return new Promise((resolve) => {
+            const expectedSsid = this.normalizeSsid(ssid);
+            if (!expectedSsid) {
+                resolve(false);
+                return;
+            }
+            this.applyHotspotConfigurationWithFallback(expectedSsid, password)
+                .then(async (err) => {
+                if (err && !this.isRecoverableHotspotConfigurationError(err)) {
+                    this.logHotspotConfigurationError(err);
+                    resolve(false);
+                    return;
+                }
+                const connected = await this.waitUntil(async () => {
+                    const currentSsid = await this.getSSIDAsync();
+                    return currentSsid === expectedSsid;
+                }, milliseconds, ConnectivityManagerImpl.POLL_INTERVAL_MS);
+                if (connected) {
+                    this.previousSsid = expectedSsid;
+                }
+                else {
+                    console.log("Timed out while waiting to connect to SSID '" + expectedSsid + "'.");
+                }
+                resolve(connected);
+            })
+                .catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    disconnectWifiNetwork(timeoutMs) {
+        return new Promise((resolve) => {
+            const ssidToDisconnect = this.normalizeSsid(this.previousSsid);
+            if (!ssidToDisconnect) {
+                resolve(true);
+                return;
+            }
+            NEHotspotConfigurationManager.sharedManager.removeConfigurationForSSID(ssidToDisconnect);
+            this.waitUntil(async () => {
+                const currentSsid = await this.getSSIDAsync();
+                return currentSsid !== ssidToDisconnect;
+            }, timeoutMs, ConnectivityManagerImpl.POLL_INTERVAL_MS).then((disconnected) => {
+                if (disconnected && this.previousSsid === ssidToDisconnect) {
+                    this.previousSsid = undefined;
+                    this.cachedSsid = null;
+                }
+                else if (!disconnected) {
+                    console.log("Timed out while waiting to disconnect from SSID '" +
+                        ssidToDisconnect +
+                        "'.");
+                }
+                resolve(disconnected);
+            });
+        });
+    }
+}
+ConnectivityManagerImpl.POLL_INTERVAL_MS = 200;
+ConnectivityManagerImpl.SSID_FETCH_TIMEOUT_MS = 1500;
+ConnectivityManagerImpl.HOTSPOT_ERROR_PENDING = 9;
+ConnectivityManagerImpl.HOTSPOT_ERROR_JOIN_ONCE_NOT_SUPPORTED = 12;
+ConnectivityManagerImpl.HOTSPOT_ERROR_ALREADY_ASSOCIATED = 13;
+//# sourceMappingURL=connectivity-manager-impl.ios.js.map

package/connectivity-manager-interface.d.ts

@@ -0,0 +1,15 @@
+export interface ConnectivityManagerInterface {
+    getSSID(): string;
+    getSSIDAsync(): Promise<string | null>;
+    getWifiNetworkId(): number;
+    isWifiEnabled(): boolean;
+    isWifiConnected(): boolean;
+    isCellularEnabled(): boolean;
+    isCellularConnected(): boolean;
+    isGpsEnabled(): boolean;
+    isGpsConnected(): boolean;
+    hasInternet(): boolean;
+    scanWifiNetworks(): Promise<string[]>;
+    connectToWifiNetwork(ssid: string, password: string, milliseconds: number): Promise<boolean>;
+    disconnectWifiNetwork(timeoutMs: number): Promise<boolean>;
+}

package/connectivity-manager-interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=connectivity-manager-interface.js.map

package/package.json

@@ -1,25 +1,34 @@
-{
-  "name": "@pietro-fe01/nativescript-connectivity-manager-plugin",
-  "version": "0.1.0",
-  "description": "This plugin provides a connectivity manager of Android and iOS.",
-  "main": "connectivity-manager-impl",
-  "typings": "index.d.ts",
-  "nativescript": {
-    "platforms": {
-      "android": "7.0.0",
-      "ios": "7.0.0"
-    }
+{
+  "name": "@pietro-fe01/nativescript-connectivity-manager-plugin",
+  "version": "0.1.1",
+  "description": "This plugin provides a connectivity manager of Android and iOS.",
+  "main": "connectivity-manager-impl",
+  "typings": "index.d.ts",
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "platforms/",
+    "README.md",
+    "LICENSE"
+  ],
+  "nativescript": {
+    "platforms": {
+      "android": "7.0.0",
+      "ios": "7.0.0"
+    }
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Pietro-fe01/nativescript-connectivity-manager-plugin.git"
   },
-  "scripts": {
-    "build": "node scripts/build-native.js",
-    "demo:reset": "cd ../demo-angular && npx rimraf -- hooks node_modules platforms package-lock.json",
-    "demo:ios": "npm i && cd ../demo-angular && tns run ios",
-    "demo:android": "npm i && cd ../demo-angular && tns run android --watch",
-    "plugin:prepare": "npm run build && cd ../demo-angular && tns plugin remove nativescript-connectivity-manager-plugin && tns plugin add ../src && cd ../demo-angular && tns plugin remove nativescript-connectivity-manager-plugin && tns plugin add ../src"
+  "scripts": {
+    "build": "node scripts/build-native.js",
+    "compile": "tsc -p tsconfig.json",
+    "prepack": "npm run compile",
+    "demo:reset": "cd ../demo-angular && npx rimraf -- hooks node_modules platforms package-lock.json",
+    "demo:ios": "npm i && cd ../demo-angular && tns run ios",
+    "demo:android": "npm i && cd ../demo-angular && tns run android --watch",
+    "plugin:prepare": "npm run build && cd ../demo-angular && tns plugin remove nativescript-connectivity-manager-plugin && tns plugin add ../src && cd ../demo-angular && tns plugin remove nativescript-connectivity-manager-plugin && tns plugin add ../src"
   },
   "keywords": [
     "IoT",

package/platforms/android/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">
+
+	<!--Describe the permissions, features or other configurations required by your plugin for Android.
+		To read more about android permissions go to https://developer.android.com/guide/topics/permissions/index.html -->
+	<!--EXAMPLE: uses-permission android:name="android.permission.INTERNET"/> -->
+
+	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+  <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
+	<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+	<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
+	<uses-permission android:name="android.permission.WRITE_SETTINGS" tools:ignore="ProtectedPermissions"/>
+</manifest>

package/platforms/android/README.md

@@ -0,0 +1,9 @@
+# Android permissions and dependencies
+
+* (Optional) Use AndroidManifest.xml to describe any permissions, features or other configuration specifics required or used by your plugin for Android. 
+NOTE: The NativeScript CLI will not resolve any contradicting or duplicate entries during the merge. After the plugin is installed, you need to manually resolve such issues.
+
+* (Optional) Use include.gradle configuration to describe any native dependencies. If there are no such, this file can be removed. For more information, see the [include.gradle Specification](http://docs.nativescript.org/plugins/plugins#includegradle-specification)
+
+
+[Read more about nativescript plugins](http://docs.nativescript.org/plugins/plugins)