android8.0 9.0 10.0获取当前WIFI

移动开发 2023-07-01 09:00:51 阅读次数: 0

Android8.0添加权限

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />


android9.0添加权限，打开GPS

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
 <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>


Android10.0添加权限

<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>

判断GPS是否打开

/**
 * 判断GPS是否开启，GPS或者AGPS开启一个就认为是开启的
 *
 * @param context 上下文
 * @return true 表示开启
 */
public static boolean isOpen(final Context context) {
    LocationManager locationManager
            = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
    // 通过GPS卫星定位，定位级别可以精确到街（通过24颗卫星定位，在室外和空旷的地方定位准确、速度快）
    boolean gps = Objects.requireNonNull(locationManager).isProviderEnabled(LocationManager.GPS_PROVIDER);
    // 通过WLAN或移动网络(3G/2G)确定的位置（也称作AGPS，辅助GPS定位。主要用于在室内或遮盖物（建筑群或茂密的深林等）密集的地方定位）
    boolean network = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    return gps || network;
}

打开GPS

if (!GpsHelper.isOpen(this)) {
    Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivityForResult(intent, REQUEST_GPS);
}

package com.jzqf.library.util;

import android.Manifest;
import android.annotation.SuppressLint;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.text.TextUtils;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.annotation.RequiresPermission;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.List;


/**
 * 获取网络信息的工具类
 * 2020/5/6 10:43
 *
 * @author LiuWeiHao
 * Email [email protected]
 */
public class NetWorkHelper {
    private static final String TAG = "NetWorkHelper";
    private static NetWorkHelper mInstance;
    /**
     * 是否已经注册回调
     */
    private static boolean isRegisted = false;
    private ConnectivityManager connectivityManager;
    /**
     * 网络是否可用
     */
    private boolean isNetWorkAvailable = false;
    /**
     * 网络类型
     */
    private NetType netType;
    private NetworkCallbackImpl networkCallbackImpl;

    /**
     * 获取NetWorkHelper实例
     */
    public static NetWorkHelper getInstance() {
        if (mInstance == null) {
            synchronized (NetWorkHelper.class) {
                if (mInstance == null) {
                    mInstance = new NetWorkHelper();
                }
            }
        }
        return mInstance;
    }

    private NetWorkHelper() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            networkCallbackImpl = new NetworkCallbackImpl();
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    class NetworkCallbackImpl extends ConnectivityManager.NetworkCallback {
        @Override
        public void onAvailable(@NonNull Network network) {
            super.onAvailable(network);
            isNetWorkAvailable = true;
            LogHelper.i(TAG, "onAvailable");
        }

        @Override
        public void onLosing(@NonNull Network network, int maxMsToLive) {
            super.onLosing(network, maxMsToLive);
            isNetWorkAvailable = false;
            LogHelper.i(TAG, "onLosing");
        }

        @Override
        public void onLost(@NonNull Network network) {
            super.onLost(network);
            isNetWorkAvailable = false;
            LogHelper.i(TAG, "onLost");
        }

        @Override
        public void onUnavailable() {
            super.onUnavailable();
            isNetWorkAvailable = false;
            LogHelper.i(TAG, "onUnavailable");
        }

        @Override
        public void onCapabilitiesChanged(@NonNull Network network, @NonNull NetworkCapabilities networkCapabilities) {
            super.onCapabilitiesChanged(network, networkCapabilities);
            if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
                isNetWorkAvailable = true;
            }
            if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
                    networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI_AWARE)) {
                netType = NetType.WIFI;
            } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) {
                netType = NetType.BLUETOOTH;
            } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                netType = NetType.CELLULAR;
            } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
                netType = NetType.ETHERNET;
            }
            LogHelper.i(TAG, "onCapabilitiesChanged");
        }

        @Override
        public void onLinkPropertiesChanged(@NonNull Network network, @NonNull LinkProperties linkProperties) {
            super.onLinkPropertiesChanged(network, linkProperties);
            LogHelper.i(TAG, "onLinkPropertiesChanged");
        }

        @Override
        public void onBlockedStatusChanged(@NonNull Network network, boolean blocked) {
            super.onBlockedStatusChanged(network, blocked);
            LogHelper.i(TAG, "onBlockedStatusChanged");
        }
    }

    /**
     * 注册回调
     */
    @RequiresPermission(Manifest.permission.CHANGE_NETWORK_STATE)
    public void registerCallback(Context context) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !isRegisted) {
            connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            if (connectivityManager != null) {
                isRegisted = true;
                connectivityManager.requestNetwork(new NetworkRequest.Builder().build(), networkCallbackImpl);
            }
        }
    }

    /**
     * 取消注册
     */

    public void unRegisterCallback() {
        if (connectivityManager != null && isRegisted) {
            isRegisted = false;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                connectivityManager.unregisterNetworkCallback(networkCallbackImpl);
            }
        }
    }


    enum NetType {
        /**
         * wifi
         */
        WIFI,
        BLUETOOTH,
        CELLULAR,
        ETHERNET,
    }

    public boolean isNetWorkAvailable() {
        return isNetWorkAvailable;
    }

    public NetType getNetType() {
        return netType;
    }

    @RequiresPermission(Manifest.permission.ACCESS_NETWORK_STATE)
    public boolean isAvailable(Context context) {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            return isNetWorkAvailable;
        } else {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = null;
            if (connectivityManager != null) {
                networkInfo = connectivityManager.getActiveNetworkInfo();
            }
            return networkInfo != null && networkInfo.isConnected();
        }
    }

    /**
     * WIFI是否可用
     *
     * @param context 上下文
     * @return WIFI是否可用
     */
    public static boolean isWifiEnabled(Context context) {
        WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        return wifiManager != null && wifiManager.isWifiEnabled();
    }

    /**
     * 获取当前WIFI名称
     *
     * @param context 上下文
     * @return 当前WIFI名称
     */
    @SuppressLint("ObsoleteSdkInt")
    public static String getCurrentSsid(Context context) {
        String ssid = "unknown id";

        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.O
                || Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {

            WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

            assert wifiManager != null;
            WifiInfo info = wifiManager.getConnectionInfo();

            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
                ssid = info.getSSID();
            } else {
                ssid = info.getSSID().replace("\"", "");
            }
            if (!TextUtils.isEmpty(ssid)) {
                Log.d(TAG, "ssid=" + ssid);
                return ssid;
            }
            //部分手机拿不到WiFi名称
            int networkId = info.getNetworkId();
            Log.d(TAG, "networkId=" + networkId);
            List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
            for (WifiConfiguration config : configuredNetworks) {
                if (config.networkId == networkId) {
                    ssid = config.SSID;
                    break;
                }
            }
            //扫描到的网络
            List<ScanResult> scanResults = wifiManager.getScanResults();
            for (ScanResult scanResult : scanResults) {
                String bssid = scanResult.SSID;
            }
            return ssid;
        } else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.O_MR1) {

            ConnectivityManager connManager = (ConnectivityManager) context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
            Network[] allNetworks = connManager.getAllNetworks();
            assert connManager != null;
            NetworkInfo networkInfo = connManager.getActiveNetworkInfo();
            if (networkInfo.isConnected()) {
                if (networkInfo.getExtraInfo() != null) {
                    return networkInfo.getExtraInfo().replace("\"", "");
                }
            }
        }
        return ssid;
    }

    /**
     * 是否5G网络
     *
     * @param ssid    wifi名称
     * @param context 上下文
     * @return 是否5G网络
     */
    public static boolean is5GHz(String ssid, Context context) {
        WifiManager wifiManger = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        if (wifiManger == null) {
            return false;
        }
        WifiInfo wifiInfo = wifiManger.getConnectionInfo();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            int freq = wifiInfo.getFrequency();
            return freq > 4900 && freq < 5900;
        } else {
            return ssid.toUpperCase().endsWith("5G");
        }
    }

    public static String getIPAddress(Context context) {
        NetworkInfo info = ((ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        if (info != null && info.isConnected()) {
            if (info.getType() == ConnectivityManager.TYPE_MOBILE) {//当前使用2G/3G/4G网络
                try {
                    //Enumeration<NetworkInterface> en=NetworkInterface.getNetworkInterfaces();
                    for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
                        NetworkInterface intf = en.nextElement();
                        for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                            InetAddress inetAddress = enumIpAddr.nextElement();
                            if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
                                return inetAddress.getHostAddress();
                            }
                        }
                    }
                } catch (SocketException e) {
                    e.printStackTrace();
                }

            } else if (info.getType() == ConnectivityManager.TYPE_WIFI) {//当前使用无线网络
                WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                String ipAddress = intIP2StringIP(wifiInfo.getIpAddress());//得到IPV4地址
                return ipAddress;
            }
        } else {
            //当前无网络连接,请在设置中打开网络
        }
        return null;
    }

    /**
     * 将得到的int类型的IP转换为String类型
     *
     * @param ip
     * @return
     */
    public static String intIP2StringIP(int ip) {
        return (ip & 0xFF) + "." +
                ((ip >> 8) & 0xFF) + "." +
                ((ip >> 16) & 0xFF) + "." +
                (ip >> 24 & 0xFF);
    }

}

猜你喜欢

转载自blog.csdn.net/jerry872235631/article/details/106358325
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022