@capacitor/network 1.0.7 → 4.0.0-nightly-44c040f.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 4.0.0-beta.0 (2022-06-27)
+
+
+### Bug Fixes
+
+* inline source code in esm map files ([#760](https://github.com/ionic-team/capacitor-plugins/issues/760)) ([a960489](https://github.com/ionic-team/capacitor-plugins/commit/a960489a19db0182b90d187a50deff9dfbe51038))
+* Make removeAllListeners return a promise ([#895](https://github.com/ionic-team/capacitor-plugins/issues/895)) ([e5c49d6](https://github.com/ionic-team/capacitor-plugins/commit/e5c49d64445dca70286334e6a0441d8021197b13))
+* **network:** Don't add window event listeners if there is no window ([#678](https://github.com/ionic-team/capacitor-plugins/issues/678)) ([0c65780](https://github.com/ionic-team/capacitor-plugins/commit/0c657808083a7f4245027a2248816b3921b813bf))
+* add es2017 lib to tsconfig ([#180](https://github.com/ionic-team/capacitor-plugins/issues/180)) ([2c3776c](https://github.com/ionic-team/capacitor-plugins/commit/2c3776c38ca025c5ee965dec10ccf1cdb6c02e2f))
+* better ignore rules for npm distribution ([#32](https://github.com/ionic-team/capacitor-plugins/issues/32)) ([b8d55b9](https://github.com/ionic-team/capacitor-plugins/commit/b8d55b9233e4ad7b8a1cd41110b4e580fc2a059f))
+* correct addListeners links ([#655](https://github.com/ionic-team/capacitor-plugins/issues/655)) ([f9871e7](https://github.com/ionic-team/capacitor-plugins/commit/f9871e7bd53478addb21155e148829f550c0e457))
+* remove postpublish scripts ([#656](https://github.com/ionic-team/capacitor-plugins/issues/656)) ([ed6ac49](https://github.com/ionic-team/capacitor-plugins/commit/ed6ac499ebf4a47525071ccbfc36c27503e11f60))
+* support deprecated types from Capacitor 2 ([#139](https://github.com/ionic-team/capacitor-plugins/issues/139)) ([2d7127a](https://github.com/ionic-team/capacitor-plugins/commit/2d7127a488e26f0287951921a6db47c49d817336))
+
+
+### Features
+
+* add commonjs output format ([#179](https://github.com/ionic-team/capacitor-plugins/issues/179)) ([8e9e098](https://github.com/ionic-team/capacitor-plugins/commit/8e9e09862064b3f6771d7facbc4008e995d9b463))
+* Network plugin ([#8](https://github.com/ionic-team/capacitor-plugins/issues/8)) ([08d9891](https://github.com/ionic-team/capacitor-plugins/commit/08d9891710d576ee3c660b4d8dce89c4169d3e0b))
+* set targetSDK default value to 31 ([#824](https://github.com/ionic-team/capacitor-plugins/issues/824)) ([3ee10de](https://github.com/ionic-team/capacitor-plugins/commit/3ee10de98067984c1a4e75295d001c5a895c47f4))
+* set targetSDK default value to 32 ([#970](https://github.com/ionic-team/capacitor-plugins/issues/970)) ([fa70d96](https://github.com/ionic-team/capacitor-plugins/commit/fa70d96f141af751aae53ceb5642c46b204f5958))
+* Upgrade gradle to 7.4 ([#826](https://github.com/ionic-team/capacitor-plugins/issues/826)) ([5db0906](https://github.com/ionic-team/capacitor-plugins/commit/5db0906f6264287c4f8e69dbaecf19d4d387824b))
+* Use java 11 ([#910](https://github.com/ionic-team/capacitor-plugins/issues/910)) ([5acb2a2](https://github.com/ionic-team/capacitor-plugins/commit/5acb2a288a413492b163e4e97da46a085d9e4be0))
+
+
+
+
+
 ## [1.0.7](https://github.com/ionic-team/capacitor-plugins/compare/@capacitor/network@1.0.6...@capacitor/network@1.0.7) (2022-01-19)
 
 

package/CapacitorNetwork.podspec

@@ -11,8 +11,7 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => 'https://github.com/ionic-team/capacitor-plugins.git', :tag => package['name'] + '@' + package['version'] }
   s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}', 'network/ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
-  s.ios.deployment_target  = '12.0'
+  s.ios.deployment_target  = '13.0'
   s.dependency 'Capacitor'
-  s.dependency 'ReachabilitySwift', '~> 5.0'
   s.swift_version = '5.1'
 end

package/android/build.gradle

@@ -1,8 +1,8 @@
 ext {
-    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.1'
-    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.2.0'
-    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.2'
-    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.3.0'
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.4.2'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.3'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.4.0'
 }
 
 buildscript {
@@ -11,17 +11,17 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.2.1'
+        classpath 'com.android.tools.build:gradle:7.2.1'
     }
 }
 
 apply plugin: 'com.android.library'
 
 android {
-    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 30
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 32
     defaultConfig {
-        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 21
-        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 30
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 32
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -36,15 +36,14 @@ android {
         abortOnError false
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
     }
 }
 
 repositories {
     google()
     mavenCentral()
-    jcenter()
 }
 
 

package/android/src/main/java/com/capacitorjs/plugins/network/Network.java

@@ -1,13 +1,17 @@
 package com.capacitorjs.plugins.network;
 
+import android.annotation.TargetApi;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
-import android.net.NetworkInfo;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.NetworkCapabilities;
+import android.os.Build;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
 import androidx.appcompat.app.AppCompatActivity;
 
 public class Network {
@@ -16,12 +20,29 @@ public class Network {
      * Interface for callbacks when network status changes.
      */
     interface NetworkStatusChangeListener {
-        void onNetworkStatusChanged();
+        void onNetworkStatusChanged(boolean wasLostEvent);
+    }
+
+    class ConnectivityCallback extends NetworkCallback {
+
+        @Override
+        public void onLost(@NonNull android.net.Network network) {
+            super.onLost(network);
+            statusChangeListener.onNetworkStatusChanged(true);
+        }
+
+        @Override
+        public void onCapabilitiesChanged(@NonNull android.net.Network network, @NonNull NetworkCapabilities networkCapabilities) {
+            super.onCapabilitiesChanged(network, networkCapabilities);
+            statusChangeListener.onNetworkStatusChanged(false);
+        }
     }
 
     @Nullable
     private NetworkStatusChangeListener statusChangeListener;
 
+    private ConnectivityCallback connectivityCallback;
+    private Context context;
     private ConnectivityManager connectivityManager;
     private BroadcastReceiver receiver;
 
@@ -29,15 +50,21 @@ public class Network {
      * Create network monitoring object.
      * @param context
      */
+    @SuppressWarnings("deprecation")
     public Network(@NonNull Context context) {
-        connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
-        receiver =
-            new BroadcastReceiver() {
-                @Override
-                public void onReceive(Context context, Intent intent) {
-                    statusChangeListener.onNetworkStatusChanged();
-                }
-            };
+        this.context = context;
+        this.connectivityManager = (ConnectivityManager) this.context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) {
+            receiver =
+                new BroadcastReceiver() {
+                    @Override
+                    public void onReceive(Context context, Intent intent) {
+                        statusChangeListener.onNetworkStatusChanged(false);
+                    }
+                };
+        } else {
+            this.connectivityCallback = new ConnectivityCallback();
+        }
     }
 
     /**
@@ -59,25 +86,73 @@ public class Network {
 
     /**
      * Get the current network information.
-     * @return NetworkInfo
+     * @return NetworkStatus
      */
-    public NetworkInfo getNetworkStatus() {
-        return connectivityManager.getActiveNetworkInfo();
+    public NetworkStatus getNetworkStatus() {
+        NetworkStatus networkStatus = new NetworkStatus();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            if (this.connectivityManager != null) {
+                android.net.Network activeNetwork = this.connectivityManager.getActiveNetwork();
+                NetworkCapabilities capabilities =
+                    this.connectivityManager.getNetworkCapabilities(this.connectivityManager.getActiveNetwork());
+                if (activeNetwork != null && capabilities != null) {
+                    networkStatus.connected =
+                        capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) &&
+                        capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+                    if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                        networkStatus.connectionType = NetworkStatus.ConnectionType.WIFI;
+                    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+                        networkStatus.connectionType = NetworkStatus.ConnectionType.CELLULAR;
+                    } else {
+                        networkStatus.connectionType = NetworkStatus.ConnectionType.UNKNOWN;
+                    }
+                }
+            }
+        } else {
+            networkStatus = getAndParseNetworkInfo();
+        }
+        return networkStatus;
+    }
+
+    @SuppressWarnings("deprecation")
+    private NetworkStatus getAndParseNetworkInfo() {
+        NetworkStatus networkStatus = new NetworkStatus();
+        android.net.NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
+        if (networkInfo != null) {
+            networkStatus.connected = networkInfo.isConnected();
+            String typeName = networkInfo.getTypeName();
+            if (typeName.equals("WIFI")) {
+                networkStatus.connectionType = NetworkStatus.ConnectionType.WIFI;
+            } else if (typeName.equals("MOBILE")) {
+                networkStatus.connectionType = NetworkStatus.ConnectionType.CELLULAR;
+            }
+        }
+        return networkStatus;
     }
 
     /**
-     * Register a Intent Receiver in the activity.
-     * @param activity
+     * Register a network callback.
      */
-    public void startMonitoring(@NonNull AppCompatActivity activity) {
-        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    public void startMonitoring() {
+        connectivityManager.registerDefaultNetworkCallback(connectivityCallback);
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
+    public void startMonitoring(AppCompatActivity activity) {
+        IntentFilter filter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
         activity.registerReceiver(receiver, filter);
     }
 
     /**
-     * Unregister the IntentReceiver to avoid leaking it.
-     * @param activity
+     * Unregister the network callback.
      */
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    public void stopMonitoring() {
+        connectivityManager.unregisterNetworkCallback(connectivityCallback);
+    }
+
+    @TargetApi(Build.VERSION_CODES.M)
     public void stopMonitoring(@NonNull AppCompatActivity activity) {
         activity.unregisterReceiver(receiver);
     }

package/android/src/main/java/com/capacitorjs/plugins/network/NetworkPlugin.java

@@ -1,14 +1,11 @@
 package com.capacitorjs.plugins.network;
 
-import android.Manifest;
-import android.net.NetworkInfo;
+import android.os.Build;
 import com.getcapacitor.JSObject;
-import com.getcapacitor.Logger;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
-import com.getcapacitor.annotation.Permission;
 
 @CapacitorPlugin(name = "Network")
 public class NetworkPlugin extends Plugin {
@@ -22,7 +19,17 @@ public class NetworkPlugin extends Plugin {
     @Override
     public void load() {
         implementation = new Network(getContext());
-        implementation.setStatusChangeListener(this::updateNetworkStatus);
+        Network.NetworkStatusChangeListener listener = wasLostEvent -> {
+            if (wasLostEvent) {
+                JSObject jsObject = new JSObject();
+                jsObject.put("connected", false);
+                jsObject.put("connectionType", "none");
+                notifyListeners(NETWORK_CHANGE_EVENT, jsObject);
+            } else {
+                updateNetworkStatus();
+            }
+        };
+        implementation.setStatusChangeListener(listener);
     }
 
     /**
@@ -39,7 +46,7 @@ public class NetworkPlugin extends Plugin {
      */
     @PluginMethod
     public void getStatus(PluginCall call) {
-        call.resolve(getStatusJSObject(implementation.getNetworkStatus()));
+        call.resolve(parseNetworkStatus(implementation.getNetworkStatus()));
     }
 
     /**
@@ -47,7 +54,11 @@ public class NetworkPlugin extends Plugin {
      */
     @Override
     protected void handleOnResume() {
-        implementation.startMonitoring(getActivity());
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            implementation.startMonitoring();
+        } else {
+            implementation.startMonitoring(getActivity());
+        }
     }
 
     /**
@@ -55,43 +66,21 @@ public class NetworkPlugin extends Plugin {
      */
     @Override
     protected void handleOnPause() {
-        implementation.stopMonitoring(getActivity());
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            implementation.stopMonitoring();
+        } else {
+            implementation.stopMonitoring(getActivity());
+        }
     }
 
     private void updateNetworkStatus() {
-        notifyListeners(NETWORK_CHANGE_EVENT, getStatusJSObject(implementation.getNetworkStatus()));
-    }
-
-    /**
-     * Transform a NetworkInfo object into our JSObject for returning to client
-     * @param info
-     * @return
-     */
-    private JSObject getStatusJSObject(NetworkInfo info) {
-        JSObject ret = new JSObject();
-        if (info == null) {
-            ret.put("connected", false);
-            ret.put("connectionType", "none");
-        } else {
-            ret.put("connected", info.isConnected());
-            ret.put("connectionType", getNormalizedTypeName(info));
-        }
-        return ret;
+        notifyListeners(NETWORK_CHANGE_EVENT, parseNetworkStatus(implementation.getNetworkStatus()));
     }
 
-    /**
-     * Convert the Android-specific naming for network types into our cross-platform type
-     * @param info
-     * @return
-     */
-    private String getNormalizedTypeName(NetworkInfo info) {
-        String typeName = info.getTypeName();
-        if (typeName.equals("WIFI")) {
-            return "wifi";
-        }
-        if (typeName.equals("MOBILE")) {
-            return "cellular";
-        }
-        return "none";
+    private JSObject parseNetworkStatus(NetworkStatus networkStatus) {
+        JSObject jsObject = new JSObject();
+        jsObject.put("connected", networkStatus.connected);
+        jsObject.put("connectionType", networkStatus.connectionType.getConnectionType());
+        return jsObject;
     }
 }

package/android/src/main/java/com/capacitorjs/plugins/network/NetworkStatus.java

@@ -0,0 +1,24 @@
+package com.capacitorjs.plugins.network;
+
+public class NetworkStatus {
+
+    public enum ConnectionType {
+        WIFI("wifi"),
+        CELLULAR("cellular"),
+        NONE("none"),
+        UNKNOWN("unknown");
+
+        private String connectionType;
+
+        ConnectionType(String connectionType) {
+            this.connectionType = connectionType;
+        }
+
+        public String getConnectionType() {
+            return this.connectionType;
+        }
+    }
+
+    public boolean connected = false;
+    public ConnectionType connectionType = ConnectionType.NONE;
+}

package/ios/Plugin/Network.swift

@@ -1,5 +1,4 @@
 import Foundation
-import Reachability
 
 public typealias NetworkConnectionChangedObserver = (Network.Connection) -> Void
 
@@ -37,7 +36,7 @@ public class Network {
 fileprivate extension Reachability.Connection {
     var equivalentEnum: Network.Connection {
         switch self {
-        case .unavailable, .none:
+        case .unavailable:
             return .unavailable
         case .wifi:
             return .wifi

package/ios/Plugin/NetworkPlugin.m

@@ -5,5 +5,5 @@
 // each method the plugin supports using the CAP_PLUGIN_METHOD macro.
 CAP_PLUGIN(CAPNetworkPlugin, "Network",
   CAP_PLUGIN_METHOD(getStatus, CAPPluginReturnPromise);
-  CAP_PLUGIN_METHOD(removeAllListeners, CAPPluginReturnNone);
+  CAP_PLUGIN_METHOD(removeAllListeners, CAPPluginReturnPromise);
 )

package/ios/Plugin/Reachability.swift

@@ -0,0 +1,395 @@
+/*
+ Copyright (c) 2014, Ashley Mills
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import SystemConfiguration
+import Foundation
+
+public enum ReachabilityError: Error {
+    case failedToCreateWithAddress(sockaddr, Int32)
+    case failedToCreateWithHostname(String, Int32)
+    case unableToSetCallback(Int32)
+    case unableToSetDispatchQueue(Int32)
+    case unableToGetFlags(Int32)
+}
+
+@available(*, unavailable, renamed: "Notification.Name.reachabilityChanged")
+public let reachabilityChangedNotification = NSNotification.Name("ReachabilityChangedNotification")
+
+public extension Notification.Name {
+    static let reachabilityChanged = Notification.Name("reachabilityChanged")
+}
+
+public class Reachability {
+
+    public typealias NetworkReachable = (Reachability) -> Void
+    public typealias NetworkUnreachable = (Reachability) -> Void
+
+    @available(*, unavailable, renamed: "Connection")
+    public enum NetworkStatus: CustomStringConvertible {
+        case notReachable, reachableViaWiFi, reachableViaWWAN
+        public var description: String {
+            switch self {
+            case .reachableViaWWAN: return "Cellular"
+            case .reachableViaWiFi: return "WiFi"
+            case .notReachable: return "No Connection"
+            }
+        }
+    }
+
+    public enum Connection: CustomStringConvertible {
+        case unavailable, wifi, cellular
+        public var description: String {
+            switch self {
+            case .cellular: return "Cellular"
+            case .wifi: return "WiFi"
+            case .unavailable: return "No Connection"
+            }
+        }
+
+        @available(*, deprecated, renamed: "unavailable")
+        public static let none: Connection = .unavailable
+    }
+
+    public var whenReachable: NetworkReachable?
+    public var whenUnreachable: NetworkUnreachable?
+
+    @available(*, deprecated, renamed: "allowsCellularConnection")
+    public let reachableOnWWAN: Bool = true
+
+    /// Set to `false` to force Reachability.connection to .none when on cellular connection (default value `true`)
+    public var allowsCellularConnection: Bool
+
+    // The notification center on which "reachability changed" events are being posted
+    public var notificationCenter: NotificationCenter = NotificationCenter.default
+
+    @available(*, deprecated, renamed: "connection.description")
+    public var currentReachabilityString: String {
+        return "\(connection)"
+    }
+
+    @available(*, unavailable, renamed: "connection")
+    public var currentReachabilityStatus: Connection {
+        return connection
+    }
+
+    public var connection: Connection {
+        if flags == nil {
+            try? setReachabilityFlags()
+        }
+
+        switch flags?.connection {
+        case .unavailable?, nil: return .unavailable
+        case .cellular?: return allowsCellularConnection ? .cellular : .unavailable
+        case .wifi?: return .wifi
+        }
+    }
+
+    fileprivate var isRunningOnDevice: Bool = {
+        #if targetEnvironment(simulator)
+        return false
+        #else
+        return true
+        #endif
+    }()
+
+    fileprivate(set) var notifierRunning = false
+    fileprivate let reachabilityRef: SCNetworkReachability
+    fileprivate let reachabilitySerialQueue: DispatchQueue
+    fileprivate let notificationQueue: DispatchQueue?
+    fileprivate(set) var flags: SCNetworkReachabilityFlags? {
+        didSet {
+            guard flags != oldValue else { return }
+            notifyReachabilityChanged()
+        }
+    }
+
+    public required init(reachabilityRef: SCNetworkReachability,
+                         queueQoS: DispatchQoS = .default,
+                         targetQueue: DispatchQueue? = nil,
+                         notificationQueue: DispatchQueue? = .main) {
+        self.allowsCellularConnection = true
+        self.reachabilityRef = reachabilityRef
+        self.reachabilitySerialQueue = DispatchQueue(label: "uk.co.ashleymills.reachability", qos: queueQoS, target: targetQueue)
+        self.notificationQueue = notificationQueue
+    }
+
+    public convenience init(hostname: String,
+                            queueQoS: DispatchQoS = .default,
+                            targetQueue: DispatchQueue? = nil,
+                            notificationQueue: DispatchQueue? = .main) throws {
+        guard let ref = SCNetworkReachabilityCreateWithName(nil, hostname) else {
+            throw ReachabilityError.failedToCreateWithHostname(hostname, SCError())
+        }
+        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue, notificationQueue: notificationQueue)
+    }
+
+    public convenience init(queueQoS: DispatchQoS = .default,
+                            targetQueue: DispatchQueue? = nil,
+                            notificationQueue: DispatchQueue? = .main) throws {
+        var zeroAddress = sockaddr()
+        zeroAddress.sa_len = UInt8(MemoryLayout<sockaddr>.size)
+        zeroAddress.sa_family = sa_family_t(AF_INET)
+
+        guard let ref = SCNetworkReachabilityCreateWithAddress(nil, &zeroAddress) else {
+            throw ReachabilityError.failedToCreateWithAddress(zeroAddress, SCError())
+        }
+
+        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue, notificationQueue: notificationQueue)
+    }
+
+    deinit {
+        stopNotifier()
+    }
+}
+
+public extension Reachability {
+
+    // MARK: - *** Notifier methods ***
+    func startNotifier() throws {
+        guard !notifierRunning else { return }
+
+        let callback: SCNetworkReachabilityCallBack = { (reachability, flags, info) in
+            guard let info = info else { return }
+
+            // `weakifiedReachability` is guaranteed to exist by virtue of our
+            // retain/release callbacks which we provided to the `SCNetworkReachabilityContext`.
+            let weakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info).takeUnretainedValue()
+
+            // The weak `reachability` _may_ no longer exist if the `Reachability`
+            // object has since been deallocated but a callback was already in flight.
+            weakifiedReachability.reachability?.flags = flags
+        }
+
+        let weakifiedReachability = ReachabilityWeakifier(reachability: self)
+        let opaqueWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.passUnretained(weakifiedReachability).toOpaque()
+
+        var context = SCNetworkReachabilityContext(
+            version: 0,
+            info: UnsafeMutableRawPointer(opaqueWeakifiedReachability),
+            retain: { (info: UnsafeRawPointer) -> UnsafeRawPointer in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                _ = unmanagedWeakifiedReachability.retain()
+                return UnsafeRawPointer(unmanagedWeakifiedReachability.toOpaque())
+            },
+            release: { (info: UnsafeRawPointer) -> Void in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                unmanagedWeakifiedReachability.release()
+            },
+            copyDescription: { (info: UnsafeRawPointer) -> Unmanaged<CFString> in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                let weakifiedReachability = unmanagedWeakifiedReachability.takeUnretainedValue()
+                let description = weakifiedReachability.reachability?.description ?? "nil"
+                return Unmanaged.passRetained(description as CFString)
+            }
+        )
+
+        if !SCNetworkReachabilitySetCallback(reachabilityRef, callback, &context) {
+            stopNotifier()
+            throw ReachabilityError.unableToSetCallback(SCError())
+        }
+
+        if !SCNetworkReachabilitySetDispatchQueue(reachabilityRef, reachabilitySerialQueue) {
+            stopNotifier()
+            throw ReachabilityError.unableToSetDispatchQueue(SCError())
+        }
+
+        // Perform an initial check
+        try setReachabilityFlags()
+
+        notifierRunning = true
+    }
+
+    func stopNotifier() {
+        defer { notifierRunning = false }
+
+        SCNetworkReachabilitySetCallback(reachabilityRef, nil, nil)
+        SCNetworkReachabilitySetDispatchQueue(reachabilityRef, nil)
+    }
+
+    // MARK: - *** Connection test methods ***
+    @available(*, deprecated, message: "Please use `connection != .none`")
+    var isReachable: Bool {
+        return connection != .unavailable
+    }
+
+    @available(*, deprecated, message: "Please use `connection == .cellular`")
+    var isReachableViaWWAN: Bool {
+        // Check we're not on the simulator, we're REACHABLE and check we're on WWAN
+        return connection == .cellular
+    }
+
+    @available(*, deprecated, message: "Please use `connection == .wifi`")
+    var isReachableViaWiFi: Bool {
+        return connection == .wifi
+    }
+
+    var description: String {
+        return flags?.description ?? "unavailable flags"
+    }
+}
+
+fileprivate extension Reachability {
+
+    func setReachabilityFlags() throws {
+        try reachabilitySerialQueue.sync { [unowned self] in
+            var flags = SCNetworkReachabilityFlags()
+            if !SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags) {
+                self.stopNotifier()
+                throw ReachabilityError.unableToGetFlags(SCError())
+            }
+
+            self.flags = flags
+        }
+    }
+
+    func notifyReachabilityChanged() {
+        let notify = { [weak self] in
+            guard let self = self else { return }
+            self.connection != .unavailable ? self.whenReachable?(self) : self.whenUnreachable?(self)
+            self.notificationCenter.post(name: .reachabilityChanged, object: self)
+        }
+
+        // notify on the configured `notificationQueue`, or the caller's (i.e. `reachabilitySerialQueue`)
+        notificationQueue?.async(execute: notify) ?? notify()
+    }
+}
+
+extension SCNetworkReachabilityFlags {
+
+    typealias Connection = Reachability.Connection
+
+    var connection: Connection {
+        guard isReachableFlagSet else { return .unavailable }
+
+        // If we're reachable, but not on an iOS device (i.e. simulator), we must be on WiFi
+        #if targetEnvironment(simulator)
+        return .wifi
+        #else
+        var connection = Connection.unavailable
+
+        if !isConnectionRequiredFlagSet {
+            connection = .wifi
+        }
+
+        if isConnectionOnTrafficOrDemandFlagSet {
+            if !isInterventionRequiredFlagSet {
+                connection = .wifi
+            }
+        }
+
+        if isOnWWANFlagSet {
+            connection = .cellular
+        }
+
+        return connection
+        #endif
+    }
+
+    var isOnWWANFlagSet: Bool {
+        #if os(iOS)
+        return contains(.isWWAN)
+        #else
+        return false
+        #endif
+    }
+    var isReachableFlagSet: Bool {
+        return contains(.reachable)
+    }
+    var isConnectionRequiredFlagSet: Bool {
+        return contains(.connectionRequired)
+    }
+    var isInterventionRequiredFlagSet: Bool {
+        return contains(.interventionRequired)
+    }
+    var isConnectionOnTrafficFlagSet: Bool {
+        return contains(.connectionOnTraffic)
+    }
+    var isConnectionOnDemandFlagSet: Bool {
+        return contains(.connectionOnDemand)
+    }
+    var isConnectionOnTrafficOrDemandFlagSet: Bool {
+        return !intersection([.connectionOnTraffic, .connectionOnDemand]).isEmpty
+    }
+    var isTransientConnectionFlagSet: Bool {
+        return contains(.transientConnection)
+    }
+    var isLocalAddressFlagSet: Bool {
+        return contains(.isLocalAddress)
+    }
+    var isDirectFlagSet: Bool {
+        return contains(.isDirect)
+    }
+    var isConnectionRequiredAndTransientFlagSet: Bool {
+        return intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]
+    }
+
+    // swiftlint:disable identifier_name
+    var description: String {
+        let W = isOnWWANFlagSet ? "W" : "-"
+        let R = isReachableFlagSet ? "R" : "-"
+        let c = isConnectionRequiredFlagSet ? "c" : "-"
+        let t = isTransientConnectionFlagSet ? "t" : "-"
+        let i = isInterventionRequiredFlagSet ? "i" : "-"
+        let C = isConnectionOnTrafficFlagSet ? "C" : "-"
+        let D = isConnectionOnDemandFlagSet ? "D" : "-"
+        let l = isLocalAddressFlagSet ? "l" : "-"
+        let d = isDirectFlagSet ? "d" : "-"
+
+        return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)"
+    }
+    // swiftlint:enable identifier_name
+}
+
+/**
+ `ReachabilityWeakifier` weakly wraps the `Reachability` class
+ in order to break retain cycles when interacting with CoreFoundation.
+ CoreFoundation callbacks expect a pair of retain/release whenever an
+ opaque `info` parameter is provided. These callbacks exist to guard
+ against memory management race conditions when invoking the callbacks.
+ #### Race Condition
+ If we passed `SCNetworkReachabilitySetCallback` a direct reference to our
+ `Reachability` class without also providing corresponding retain/release
+ callbacks, then a race condition can lead to crashes when:
+ - `Reachability` is deallocated on thread X
+ - A `SCNetworkReachability` callback(s) is already in flight on thread Y
+ #### Retain Cycle
+ If we pass `Reachability` to CoreFoundtion while also providing retain/
+ release callbacks, we would create a retain cycle once CoreFoundation
+ retains our `Reachability` class. This fixes the crashes and his how
+ CoreFoundation expects the API to be used, but doesn't play nicely with
+ Swift/ARC. This cycle would only be broken after manually calling
+ `stopNotifier()` — `deinit` would never be called.
+ #### ReachabilityWeakifier
+ By providing both retain/release callbacks and wrapping `Reachability` in
+ a weak wrapper, we:
+ - interact correctly with CoreFoundation, thereby avoiding a crash.
+ See "Memory Management Programming Guide for Core Foundation".
+ - don't alter the public API of `Reachability.swift` in any way
+ - still allow for automatic stopping of the notifier on `deinit`.
+ */
+private class ReachabilityWeakifier {
+    weak var reachability: Reachability?
+    init(reachability: Reachability) {
+        self.reachability = reachability
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/network",
-  "version": "1.0.7",
+  "version": "4.0.0-nightly-44c040f.0",
   "description": "The Network API provides network and connectivity information.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -29,7 +29,7 @@
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
-    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin && cd ..",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
@@ -45,10 +45,10 @@
     "publish:cocoapod": "pod trunk push ./CapacitorNetwork.podspec --allow-warnings"
   },
   "devDependencies": {
-    "@capacitor/android": "^3.0.0",
-    "@capacitor/core": "^3.0.0",
+    "@capacitor/android": "next",
+    "@capacitor/core": "next",
     "@capacitor/docgen": "0.0.18",
-    "@capacitor/ios": "^3.0.0",
+    "@capacitor/ios": "next",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "~1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -61,7 +61,7 @@
     "typescript": "~4.1.5"
   },
   "peerDependencies": {
-    "@capacitor/core": "^3.0.0"
+    "@capacitor/core": "next"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",
@@ -79,5 +79,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f18ee6482e1ec8e5fb0290d51f598397133af990"
+  "gitHead": "44c040f725a76414eaf5d922ffd64aa9d0c32ec6"
 }