Initial commit

sources/com/ubt/jimu/base/networkstate/NetWorkUtil.java

@@ -0,0 +1,30 @@
+package com.ubt.jimu.base.networkstate;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+
+/* loaded from: classes.dex */
+public class NetWorkUtil {
+    public static NetworkType getAPNType(Context context) {
+        if (context == null) {
+            return NetworkType.NONE_NET;
+        }
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
+        if (connectivityManager == null) {
+            return NetworkType.NONE_NET;
+        }
+        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+        if (activeNetworkInfo == null) {
+            return NetworkType.NONE_NET;
+        }
+        int type = activeNetworkInfo.getType();
+        return type == -1 ? NetworkType.NONE_NET : type == 0 ? NetworkType.MOBILE : type == 1 ? NetworkType.WIFI : NetworkType.OTHER;
+    }
+
+    public static boolean isNetworkAvailable(Context context) {
+        ConnectivityManager connectivityManager;
+        NetworkInfo activeNetworkInfo;
+        return (context == null || (connectivityManager = (ConnectivityManager) context.getSystemService("connectivity")) == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || !activeNetworkInfo.isConnected()) ? false : true;
+    }
+}

sources/com/ubt/jimu/base/networkstate/NetworkStateObserver.java

@@ -0,0 +1,8 @@
+package com.ubt.jimu.base.networkstate;
+
+/* loaded from: classes.dex */
+public interface NetworkStateObserver {
+    void onNetworkConnected(NetworkType networkType);
+
+    void onNetworkDisconnected();
+}

sources/com/ubt/jimu/base/networkstate/NetworkStateReceiver.java

@@ -0,0 +1,126 @@
+package com.ubt.jimu.base.networkstate;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+public class NetworkStateReceiver extends BroadcastReceiver {
+    private static NetworkStateReceiver receiver;
+    private NetworkType lastState;
+    private NetWorkStateListener mNetWorkStateListener;
+    private NetworkType networkType;
+    private ArrayList<NetworkStateObserver> observers = new ArrayList<>();
+    private boolean isNetworkValueable = false;
+
+    public interface NetWorkStateListener {
+        void onNetWorkStateListener(NetworkType networkType);
+    }
+
+    private NetworkStateReceiver() {
+    }
+
+    public static NetworkStateReceiver getInstance() {
+        if (receiver == null) {
+            receiver = new NetworkStateReceiver();
+        }
+        return receiver;
+    }
+
+    private void notifyObserver() {
+        ArrayList<NetworkStateObserver> arrayList = this.observers;
+        if (arrayList == null || arrayList.size() == 0) {
+            return;
+        }
+        for (int i = 0; i < this.observers.size(); i++) {
+            NetworkStateObserver networkStateObserver = this.observers.get(i);
+            try {
+                if (this.isNetworkValueable) {
+                    networkStateObserver.onNetworkConnected(this.networkType);
+                } else {
+                    networkStateObserver.onNetworkDisconnected();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public NetworkType getNetworkType() {
+        return this.networkType;
+    }
+
+    public boolean isNetworkValuebale() {
+        return this.isNetworkValueable;
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null) {
+            return;
+        }
+        try {
+            if ("android.net.conn.CONNECTIVITY_CHANGE".equals(intent.getAction())) {
+                if (NetWorkUtil.isNetworkAvailable(context)) {
+                    this.networkType = NetWorkUtil.getAPNType(context);
+                    this.isNetworkValueable = true;
+                } else {
+                    this.isNetworkValueable = false;
+                    this.networkType = NetworkType.NONE_NET;
+                }
+                if (this.mNetWorkStateListener != null && this.lastState != this.networkType && this.networkType != NetworkType.NONE_NET) {
+                    this.mNetWorkStateListener.onNetWorkStateListener(this.networkType);
+                    this.lastState = this.networkType;
+                }
+                notifyObserver();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void registerNetworkStateReceiver(Context context) {
+        if (context == null) {
+            return;
+        }
+        try {
+            IntentFilter intentFilter = new IntentFilter();
+            intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
+            context.getApplicationContext().registerReceiver(this, intentFilter);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void registerObserver(NetworkStateObserver networkStateObserver) {
+        if (this.observers == null) {
+            this.observers = new ArrayList<>();
+        }
+        this.observers.add(networkStateObserver);
+    }
+
+    public void removeObserver(NetworkStateObserver networkStateObserver) {
+        ArrayList<NetworkStateObserver> arrayList;
+        if (networkStateObserver == null || (arrayList = this.observers) == null) {
+            return;
+        }
+        arrayList.remove(networkStateObserver);
+    }
+
+    public void setNetWorkStateListener(NetWorkStateListener netWorkStateListener) {
+        this.mNetWorkStateListener = netWorkStateListener;
+    }
+
+    public void unRegisterNetworkStateReceiver(Context context) {
+        if (context == null || receiver == null) {
+            return;
+        }
+        try {
+            context.getApplicationContext().unregisterReceiver(receiver);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

sources/com/ubt/jimu/base/networkstate/NetworkType.java

@@ -0,0 +1,9 @@
+package com.ubt.jimu.base.networkstate;
+
+/* loaded from: classes.dex */
+public enum NetworkType {
+    WIFI,
+    MOBILE,
+    OTHER,
+    NONE_NET
+}