[Connectivity] migrate to the new android embedding

packages/connectivity/android/src/main/java/dev/flutter/plugins/connectivity/ConnectivityPlugin.java

@@ -4,9 +4,15 @@
 
 package dev.flutter.plugins.connectivity;
 
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.wifi.WifiManager;
 import io.flutter.embedding.engine.plugins.FlutterPlugin;
 import io.flutter.plugin.common.EventChannel;
 import io.flutter.plugin.common.MethodChannel;
+import io.flutter.plugins.connectivity.BroadcastReceiverRegistrarImpl;
+import io.flutter.plugins.connectivity.Connectivity;
+import io.flutter.plugins.connectivity.ConnectivityEventChannelHandler;
 import io.flutter.plugins.connectivity.ConnectivityMethodChannelHandler;
 
 /**
@@ -24,12 +30,30 @@ public void onAttachedToEngine(FlutterPluginBinding binding) {
     final EventChannel eventChannel =
         new EventChannel(
             binding.getFlutterEngine().getDartExecutor(), "plugins.flutter.io/connectivity_status");
+    ConnectivityManager connectivityManager =
+        (ConnectivityManager)
+            binding
+                .getApplicationContext()
+                .getApplicationContext()
+                .getSystemService(Context.CONNECTIVITY_SERVICE);
+    WifiManager wifiManager =
+        (WifiManager)
+            binding
+                .getApplicationContext()
+                .getApplicationContext()
+                .getSystemService(Context.WIFI_SERVICE);
 
-    ConnectivityMethodChannelHandler handler =
-        new ConnectivityMethodChannelHandler(binding.getApplicationContext());
+    Connectivity connectivity = new Connectivity(connectivityManager, wifiManager);
 
-    channel.setMethodCallHandler(handler);
-    eventChannel.setStreamHandler(handler);
+    ConnectivityMethodChannelHandler methodChannelHandler =
+        new ConnectivityMethodChannelHandler(connectivity);
+    channel.setMethodCallHandler(methodChannelHandler);
+
+    BroadcastReceiverRegistrarImpl receiverRegistrar =
+        new BroadcastReceiverRegistrarImpl(binding.getApplicationContext(), connectivity);
+    ConnectivityEventChannelHandler eventChannelHandler =
+        new ConnectivityEventChannelHandler(receiverRegistrar);
+    eventChannel.setStreamHandler(eventChannelHandler);
   }
 
   @Override

packages/connectivity/android/src/main/java/io/flutter/plugins/connectivity/BroadcastReceiverRegistrar.java

@@ -0,0 +1,34 @@
+package io.flutter.plugins.connectivity;
+
+import android.content.BroadcastReceiver;
+import androidx.annotation.NonNull;
+import io.flutter.plugin.common.EventChannel;
+
+/** Responsible for constructing a BroadcastReceiver as well as registering and unregistering it. */
+public interface BroadcastReceiverRegistrar {
+
+  /**
+   * Triggered when it is ready for the BroadcastReceiver to be registered. Register the receiver in
+   * this method body.
+   *
+   * @param receiver the receiver is going to be registered.
+   */
+  void readyToRegisterBroadcastReceiver(@NonNull BroadcastReceiver receiver);
+
+  /**
+   * Triggered when it is ready for the BroadcastReceiver to be unregistered. Unregister the
+   * receiver in this method body.
+   *
+   * @param receiver the receiver is going to be unregistered.
+   */
+  void readyToUnregisterBroadcastReceiver(@NonNull BroadcastReceiver receiver);
+
+  /**
+   * Creates a Broadcast receiver.
+   *
+   * @param events The events helps the broadcast receiver to dump information to the event channel.
+   * @return A BroadcastReceiver.
+   */
+  @NonNull
+  BroadcastReceiver createReceiver(@NonNull final EventChannel.EventSink events);
+}

packages/connectivity/android/src/main/java/io/flutter/plugins/connectivity/BroadcastReceiverRegistrarImpl.java

@@ -0,0 +1,45 @@
+package io.flutter.plugins.connectivity;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import androidx.annotation.NonNull;
+import io.flutter.plugin.common.EventChannel;
+
+/** The BroadcastReceiverRegistrar used for the plugin. */
+public class BroadcastReceiverRegistrarImpl implements BroadcastReceiverRegistrar {
+  private Context context;
+  private Connectivity connectivity;
+
+  /**
+   * @param context used to register and unregister the broadcastReceiver.
+   * @param connectivity used to check connectivity information.
+   */
+  public BroadcastReceiverRegistrarImpl(
+      @NonNull Context context, @NonNull Connectivity connectivity) {
+    this.context = context;
+    this.connectivity = connectivity;
+  }
+
+  @Override
+  public void readyToRegisterBroadcastReceiver(BroadcastReceiver receiver) {
+    context.registerReceiver(receiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
+  }
+
+  @Override
+  public void readyToUnregisterBroadcastReceiver(BroadcastReceiver receiver) {
+    context.unregisterReceiver(receiver);
+  }
+
+  @Override
+  public BroadcastReceiver createReceiver(final EventChannel.EventSink events) {
+    return new BroadcastReceiver() {
+      @Override
+      public void onReceive(Context context, Intent intent) {
+        events.success(connectivity.checkNetworkType());
+      }
+    };
+  }
+}

packages/connectivity/android/src/main/java/io/flutter/plugins/connectivity/Connectivity.java

@@ -0,0 +1,117 @@
+package io.flutter.plugins.connectivity;
+
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+
+/** Responsible for checking connectivity information. */
+public class Connectivity {
+  private ConnectivityManager connectivityManager;
+  private WifiManager wifiManager;
+
+  /**
+   * Constructs a ConnectivityChecker
+   *
+   * @param connectivityManager used to check connectivity information.
+   * @param wifiManager used to check wifi information.
+   */
+  public Connectivity(ConnectivityManager connectivityManager, WifiManager wifiManager) {
+    this.connectivityManager = connectivityManager;
+    this.wifiManager = wifiManager;
+  }
+
+  @NonNull
+  String checkNetworkType() {
+    return getNetworkType();
+  }
+
+  @Nullable
+  String getWifiName() {
+    WifiInfo wifiInfo = getWifiInfo();
+    String ssid = null;
+    if (wifiInfo != null) ssid = wifiInfo.getSSID();
+    if (ssid != null) ssid = ssid.replaceAll("\"", ""); // Android returns "SSID"
+    return ssid;
+  }
+
+  @Nullable
+  String getWifiBSSID() {
+    WifiInfo wifiInfo = getWifiInfo();
+    String bssid = null;
+    if (wifiInfo != null) {
+      bssid = wifiInfo.getBSSID();
+    }
+    return bssid;
+  }
+
+  @Nullable
+  String getWifiIPAddress() {
+    WifiInfo wifiInfo = null;
+    if (wifiManager != null) wifiInfo = wifiManager.getConnectionInfo();
+
+    String ip = null;
+    int i_ip = 0;
+    if (wifiInfo != null) i_ip = wifiInfo.getIpAddress();
+
+    if (i_ip != 0)
+      ip =
+          String.format(
+              "%d.%d.%d.%d",
+              (i_ip & 0xff), (i_ip >> 8 & 0xff), (i_ip >> 16 & 0xff), (i_ip >> 24 & 0xff));
+
+    return ip;
+  }
+
+  @Nullable
+  private WifiInfo getWifiInfo() {
+    return wifiManager == null ? null : wifiManager.getConnectionInfo();
+  }
+
+  private String getNetworkType() {
+    if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      Network network = connectivityManager.getActiveNetwork();
+      NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
+      if (capabilities == null) {
+        return "none";
+      }
+      if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+          || capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
+        return "wifi";
+      }
+      if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+        return "mobile";
+      }
+    }
+
+    return getNetworkTypeLegacy();
+  }
+
+  @SuppressWarnings("deprecation")
+  private String getNetworkTypeLegacy() {
+    // handle type for Android versions less than Android 9
+    NetworkInfo info = connectivityManager.getActiveNetworkInfo();
+    if (info == null || !info.isConnected()) {
+      return "none";
+    }
+    int type = info.getType();
+    switch (type) {
+      case ConnectivityManager.TYPE_ETHERNET:
+      case ConnectivityManager.TYPE_WIFI:
+      case ConnectivityManager.TYPE_WIMAX:
+        return "wifi";
+      case ConnectivityManager.TYPE_MOBILE:
+      case ConnectivityManager.TYPE_MOBILE_DUN:
+      case ConnectivityManager.TYPE_MOBILE_HIPRI:
+        return "mobile";
+      default:
+        return "none";
+    }
+  }
+}

packages/connectivity/android/src/main/java/io/flutter/plugins/connectivity/ConnectivityEventChannelHandler.java

@@ -0,0 +1,33 @@
+package io.flutter.plugins.connectivity;
+
+import android.content.BroadcastReceiver;
+import androidx.annotation.NonNull;
+import io.flutter.plugin.common.EventChannel;
+
+/** Handles the event channel for the plugin. */
+public class ConnectivityEventChannelHandler implements EventChannel.StreamHandler {
+  private final BroadcastReceiverRegistrar broadcastReceiverRegistrar;
+  private BroadcastReceiver broadcastReceiver;
+
+  /**
+   * Constructs a ConnectivityEventChannelHandler
+   *
+   * @param broadcastReceiverRegistrar handling registration of the broadcastReceiver.
+   */
+  public ConnectivityEventChannelHandler(
+      @NonNull BroadcastReceiverRegistrar broadcastReceiverRegistrar) {
+    this.broadcastReceiverRegistrar = broadcastReceiverRegistrar;
+  }
+
+  @Override
+  public void onListen(Object arguments, EventChannel.EventSink events) {
+    broadcastReceiver = broadcastReceiverRegistrar.createReceiver(events);
+    broadcastReceiverRegistrar.readyToRegisterBroadcastReceiver(broadcastReceiver);
+  }
+
+  @Override
+  public void onCancel(Object arguments) {
+    broadcastReceiverRegistrar.readyToUnregisterBroadcastReceiver(broadcastReceiver);
+    broadcastReceiver = null;
+  }
+}