[Connectivity] migrate to the new android embedding

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

@@ -0,0 +1,61 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+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;
+
+/**
+ * Plugin implementation that uses the new {@code io.flutter.embedding} package.
+ *
+ * <p>Instantiate this in an add to app scenario to gracefully handle activity and context changes.
+ */
+public class ConnectivityPlugin implements FlutterPlugin {
+
+  @Override
+  public void onAttachedToEngine(FlutterPluginBinding binding) {
+    final MethodChannel channel =
+        new MethodChannel(
+            binding.getFlutterEngine().getDartExecutor(), "plugins.flutter.io/connectivity");
+    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);
+
+    Connectivity connectivity = new Connectivity(connectivityManager, wifiManager);
+
+    ConnectivityMethodChannelHandler methodChannelHandler =
+        new ConnectivityMethodChannelHandler(connectivity);
+    channel.setMethodCallHandler(methodChannelHandler);
+
+    BroadcastReceiverRegistrarImpl receiverRegistrar =
+        new BroadcastReceiverRegistrarImpl(binding.getApplicationContext(), connectivity);
+    ConnectivityEventChannelHandler eventChannelHandler =
+        new ConnectivityEventChannelHandler(receiverRegistrar);
+    eventChannel.setStreamHandler(eventChannelHandler);
+  }
+
+  @Override
+  public void onDetachedFromEngine(FlutterPluginBinding binding) {}
+}

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;
+  }
+}

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

@@ -0,0 +1,42 @@
+package io.flutter.plugins.connectivity;
+
+import androidx.annotation.NonNull;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+
+/** Handles MethodChannel for the plugin. */
+public class ConnectivityMethodChannelHandler implements MethodChannel.MethodCallHandler {
+
+  private Connectivity connectivity;
+
+  /**
+   * Construct the ConnectivityMethodChannelHandler
+   *
+   * @param connectivity The {@link Connectivity} used to check connectivity information.
+   */
+  public ConnectivityMethodChannelHandler(@NonNull Connectivity connectivity) {
+    assert (connectivity != null);
+    this.connectivity = connectivity;
+  }
+
+  @Override
+  public void onMethodCall(MethodCall call, MethodChannel.Result result) {
+    switch (call.method) {
+      case "check":
+        result.success(connectivity.checkNetworkType());
+        break;
+      case "wifiName":
+        result.success(connectivity.getWifiName());
+        break;
+      case "wifiBSSID":
+        result.success(connectivity.getWifiBSSID());
+        break;
+      case "wifiIPAddress":
+        result.success(connectivity.getWifiIPAddress());
+        break;
+      default:
+        result.notImplemented();
+        break;
+    }
+  }
+}