0
0

【Android App】检查手机连接WiFi信息以及扫描周围WiFi的讲解及实战（附源码和演示 超详细必看）

需要全部代码请点赞关注收藏后评论区留言私信~~~

一、检查是否连接WiFi以及输出WiFi信息

传统的定位方式不适用于室内的垂直定位，原因如下： （1）卫星定位要求没有障碍物遮挡，它在户外比较精准，在室内信号就变差。 （2）基站定位依赖于运营商的通讯服务，如果身处基站信号尚未覆盖的偏僻空间，就无法使用基站定位。 室内WiFi定位纳入了IEEE的802.11标准，名叫WLAN RTT (IEEE 802.11mc)。

RTT是Round-Trip-Time的缩写，即往返时间，可以用于计算网络两端的距离

室内WiFi定义的实现步骤有以下三步

（1）检查是否连接无线网络 通过无线网络管理器WifiManager获取WiFi信息。

（2）扫描周围的无线网络 用到无线网络管理器的startScan和getScanResults两个方法。

（3）计算WiFi路由器的往返时延 通过WifiRttManager对目标路由器测距。

上网方式主要有两种 即数据连接和WiFi，不过连接管理器ConnectivityManager只能笼统地判断能否上网，并不能获知WiFi连接的详细信息，在当前网络类型是WiFi时，要想得知WiFi上网的具体信息，还需另外通过无线网络管理器WifiManager获取 它的部分方法如下

isWifiEnabled 判断WLAN功能是否开启

setWifiEnabled 开启或关闭WLAN功能

getWifiState 获取当前的WiFi连接状态

实战效果如下 会输出所连接Wifi的相关信息

代码如下

  1. package com.example.location;
  3. import com.example.location.util.IPv4Util;
  4. import com.example.location.util.NetUtil;
  6. import android.annotation.SuppressLint;
  7. import android.content.Context;
  8. import android.net.ConnectivityManager;
  9. import android.net.NetworkInfo;
  10. import android.net.wifi.WifiInfo;
  11. import android.net.wifi.WifiManager;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import androidx.appcompat.app.AppCompatActivity;
  16. import android.os.Looper;
  17. import android.telephony.TelephonyManager;
  18. import android.text.TextUtils;
  19. import android.widget.TextView;
  21. @SuppressLint("DefaultLocale")
  22. public class WifiInfoActivity extends AppCompatActivity {
  23.     private static final String TAG = "WifiInfoActivity";
  24.     private TextView tv_info; // 声明一个文本视图对象
  25.     private Handler mHandler = new Handler(Looper.myLooper()); // 声明一个处理器对象
  26.     private String[] mWifiStateArray = {"正在断开", "已断开", "正在连接", "已连接", "未知"};
  28.     @Override
  29.     protected void onCreate(Bundle savedInstanceState) {
  30.         super.onCreate(savedInstanceState);
  31.         setContentView(R.layout.activity_wifi_info);
  32.         tv_info = findViewById(R.id.tv_info);
  33.         mHandler.postDelayed(mRefresh, 50); // 延迟50毫秒后启动网络刷新任务
  34.     }
  36.     // 定义一个网络刷新任务
  37.     private Runnable mRefresh = new Runnable() {
  38.         @Override
  39.         public void run() {
  40.             getAvailableNet(); // 获取可用的网络信息
  41.             // 延迟1秒后再次启动网络刷新任务
  42.             mHandler.postDelayed(this, 1000);
  43.         }
  44.     };
  46.     // 获取可用的网络信息
  47.     private void getAvailableNet() {
  48.         String desc = "";
  49.         // 从系统服务中获取电话管理器
  50.         TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
  51.         // 从系统服务中获取连接管理器
  52.         ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
  53.         // 通过连接管理器获得可用的网络信息
  54.         NetworkInfo info = cm.getActiveNetworkInfo();
  55.         if (info != null && info.getState() == NetworkInfo.State.CONNECTED) { // 有网络连接
  56.             if (info.getType() == ConnectivityManager.TYPE_WIFI) { // WiFi网络（无线热点）
  57.                 // 从系统服务中获取无线网络管理器
  58.                 WifiManager wm = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  59.                 int state = wm.getWifiState(); // 获得无线网络的状态
  60.                 WifiInfo wifiInfo = wm.getConnectionInfo(); // 获得无线网络信息
  61.                 String SSID = wifiInfo.getSSID(); // 获得无线网络的名称
  62.                 if (TextUtils.isEmpty(SSID) || SSID.contains("unknown")) {
  63.                     desc = "\n当前联网的网络类型是WiFi，但未成功连接已知的WiFi信号";
  64.                 } else {
  65.                     desc = String.format("当前联网的网络类型是WiFi，状态是%s。\nWiFi名称是：%s\n路由器MAC是：%s\nWiFi信号强度是：%d\n连接速率是：%s\n手机的IP地址是：%s\n手机的MAC地址是：%s\n网络编号是：%s\n",
  66.                             mWifiStateArray[state], SSID, wifiInfo.getBSSID(),
  67.                             wifiInfo.getRssi(), wifiInfo.getLinkSpeed(),
  68.                             IPv4Util.intToIp(wifiInfo.getIpAddress()),
  69.                             wifiInfo.getMacAddress(), wifiInfo.getNetworkId());
  70.                 }
  71.             } else if (info.getType() == ConnectivityManager.TYPE_MOBILE) { // 移动网络（数据连接）
  72.                 int net_type = info.getSubtype();
  73.                 desc = String.format("\n当前联网的网络类型是%s %s",
  74.                         NetUtil.getNetworkTypeName(tm, net_type),
  75.                         NetUtil.getClassName(tm, net_type));
  76.             } else {
  77.                 desc = String.format("\n当前联网的网络类型是%d", info.getType());
  78.             }
  79.         } else { // 无网络连接
  80.             desc = "\n当前无上网连接";
  81.         }
  82.         tv_info.setText(desc);
  83.     }
  85. }

二、扫描周围的无线网络

扫描周边Wifi主要用到WiFi滚力气的startScan方法和getScanResults方法，前者表示开始扫描周围的网络，后者表示获取扫描的结果列表，它们两个方法不能紧跟着，因为扫描动作是异步进行的，必须等到收到扫描结束的广播，然后在广播接收器中才能获取扫描结果

点击开始扫描后结果如下 会输出附近的WiFi信息

代码如下

  1. package com.example.location;
  3. import androidx.annotation.RequiresApi;
  4. import androidx.appcompat.app.AppCompatActivity;
  6. import android.content.BroadcastReceiver;
  7. import android.content.Context;
  8. import android.content.Intent;
  9. import android.content.IntentFilter;
  10. import android.net.wifi.ScanResult;
  11. import android.net.wifi.WifiManager;
  12. import android.os.Build;
  13. import android.os.Bundle;
  14. import android.widget.ListView;
  15. import android.widget.TextView;
  17. import com.example.location.adapter.ScanListAdapter;
  19. import java.util.HashMap;
  20. import java.util.List;
  21. import java.util.Map;
  23. @RequiresApi(api = Build.VERSION_CODES.M)
  24. public class WifiScanActivity extends AppCompatActivity {
  25.     private final static String TAG = "WifiScanActivity";
  26.     private TextView tv_result; // 声明一个文本视图对象
  27.     private ListView lv_scan; // 声明一个列表视图对象
  28.     private WifiManager mWifiManager; // 声明一个WiFi管理器对象
  29.     private WifiScanReceiver mWifiScanReceiver = new WifiScanReceiver(); // 声明一个WiFi扫描接收器对象
  31.     @Override
  32.     protected void onCreate(Bundle savedInstanceState) {
  33.         super.onCreate(savedInstanceState);
  34.         setContentView(R.layout.activity_wifi_scan);
  35.         tv_result = findViewById(R.id.tv_result);
  36.         lv_scan = findViewById(R.id.lv_scan);
  37.         findViewById(R.id.btn_scan).setOnClickListener(v -> mWifiManager.startScan());
  38.         // 从系统服务中获取WiFi管理器
  39.         mWifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  40.     }
  42.     @Override
  43.     protected void onResume() {
  44.         super.onResume();
  45.         IntentFilter filter = new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
  46.         registerReceiver(mWifiScanReceiver, filter); // 注册WiFi扫描的广播接收器
  47.     }
  49.     @Override
  50.     protected void onPause() {
  51.         super.onPause();
  52.         unregisterReceiver(mWifiScanReceiver); // 注销WiFi扫描的广播接收器
  53.     }
  55.     // 定义一个扫描周边WiFi的广播接收器
  56.     private class WifiScanReceiver extends BroadcastReceiver {
  57.         @Override
  58.         public void onReceive(Context context, Intent intent) {
  59.             // 获取WiFi扫描的结果列表
  60.             List<ScanResult> scanList = mWifiManager.getScanResults();
  61.             if (scanList != null) {
  62.                 // 查找符合80211标准的WiFi路由器集合
  63.                 Map<String, ScanResult> m80211mcMap = find80211mcResults(scanList);
  64.                 runOnUiThread(() -> showScanResult(scanList, m80211mcMap));
  65.             }
  66.         }
  67.     }
  69.     // 查找符合80211标准的WiFi路由器集合
  70.     private Map<String, ScanResult> find80211mcResults(List<ScanResult> originList) {
  71.         Map<String, ScanResult> resultMap = new HashMap<>();
  72.         for (ScanResult scanResult : originList) { // 遍历扫描发现的WiFi列表
  73.             if (scanResult.is80211mcResponder()) { // 符合80211标准
  74.                 resultMap.put(scanResult.BSSID, scanResult); // BSSID表示MAC地址
  75.             }
  76.         }
  77.         return resultMap;
  78.     }
  80.     // 显示过滤后的WiFi扫描结果
  81.     private void showScanResult(List<ScanResult> list, Map<String, ScanResult> map) {
  82.         tv_result.setText(String.format("找到%d个WiFi热点，其中有%d个支持RTT。",
  83.                                         list.size(), map.size()));
  84.         lv_scan.setAdapter(new ScanListAdapter(this, list, map));
  85.     }
  87. }

三、计算往返时延RTT

这个要求路由器具备RTT功能，还要求手机支持室内wifi定位 效果如下

代码如下

  1. package com.example.location;
  3. import android.Manifest;
  4. import android.content.BroadcastReceiver;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.content.IntentFilter;
  8. import android.content.pm.PackageManager;
  9. import android.net.wifi.ScanResult;
  10. import android.net.wifi.WifiManager;
  11. import android.net.wifi.rtt.RangingRequest;
  12. import android.net.wifi.rtt.RangingResult;
  13. import android.net.wifi.rtt.RangingResultCallback;
  14. import android.net.wifi.rtt.WifiRttManager;
  15. import android.os.Build;
  16. import android.os.Bundle;
  17. import android.util.Log;
  18. import android.widget.TextView;
  20. import androidx.annotation.RequiresApi;
  21. import androidx.appcompat.app.AppCompatActivity;
  22. import androidx.core.app.ActivityCompat;
  24. import java.util.ArrayList;
  25. import java.util.List;
  27. @RequiresApi(api = Build.VERSION_CODES.P)
  28. public class WifiRttActivity extends AppCompatActivity {
  29.     private final static String TAG = "WifiRttActivity";
  30.     private TextView tv_result; // 声明一个文本视图对象
  31.     private WifiManager mWifiManager; // 声明一个WiFi管理器对象
  32.     private WifiScanReceiver mWifiScanReceiver = new WifiScanReceiver(); // 声明一个WiFi扫描接收器对象
  33.     private WifiRttManager mRttManager; // 声明一个RTT管理器对象
  34.     private WifiRttReceiver mWifiRttReceiver = new WifiRttReceiver(); // 声明一个RTT接收器对象
  36.     @Override
  37.     protected void onCreate(Bundle savedInstanceState) {
  38.         super.onCreate(savedInstanceState);
  39.         setContentView(R.layout.activity_wifi_rtt);
  40.         tv_result = findViewById(R.id.tv_result);
  41.         findViewById(R.id.btn_indoor_rtt).setOnClickListener(v -> mWifiManager.startScan());
  42.         // 从系统服务中获取WiFi管理器
  43.         mWifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  44.         // 从系统服务中获取RTT管理器
  45.         mRttManager = (WifiRttManager) getSystemService(Context.WIFI_RTT_RANGING_SERVICE);
  46.         if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_RTT)) {
  47.             tv_result.setText("当前设备支持室内WiFi定位");
  48.         } else {
  49.             tv_result.setText("当前设备不支持室内WiFi定位");
  50.         }
  51.     }
  53.     @Override
  54.     protected void onResume() {
  55.         super.onResume();
  56.         IntentFilter filterScan = new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
  57.         registerReceiver(mWifiScanReceiver, filterScan); // 注册Wifi扫描的广播接收器
  58.         IntentFilter filterRtt = new IntentFilter(WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED);
  59.         registerReceiver(mWifiRttReceiver, filterRtt); // 注册RTT状态变更的广播接收器
  60.     }
  62.     @Override
  63.     protected void onPause() {
  64.         super.onPause();
  65.         unregisterReceiver(mWifiScanReceiver); // 注销Wifi扫描的广播接收器
  66.         unregisterReceiver(mWifiRttReceiver); // 注销RTT状态变更的广播接收器
  67.     }
  69.     // 定义一个扫描周边WiFi的广播接收器
  70.     private class WifiScanReceiver extends BroadcastReceiver {
  71.         @Override
  72.         public void onReceive(Context context, Intent intent) {
  73.             // 获取WiFi扫描的结果列表
  74.             List<ScanResult> scanList = mWifiManager.getScanResults();
  75.             if (scanList != null) {
  76.                 // 查找符合80211标准的WiFi路由器集合
  77.                 List<ScanResult> m80211mcList = find80211mcResults(scanList);
  78.                 runOnUiThread(() -> {
  79.                     String desc = String.format("找到%d个Wifi热点，其中有%d个支持RTT。",
  80.                             scanList.size(), m80211mcList.size());
  81.                     tv_result.setText(desc);
  82.                 });
  83.                 if (m80211mcList.size() > 0) {
  84.                     rangingRtt(m80211mcList.get(0)); // 测量与RTT节点之间的距离
  85.                 }
  86.             }
  87.         }
  88.     }
  90.     // 查找符合80211标准的WiFi路由器集合
  91.     private List<ScanResult> find80211mcResults(List<ScanResult> originList) {
  92.         List<ScanResult> resultList = new ArrayList<>();
  93.         for (ScanResult scanResult : originList) { // 遍历扫描发现的WiFi列表
  94.             if (scanResult.is80211mcResponder()) { // 符合80211标准
  95.                 resultList.add(scanResult);
  96.             }
  97.         }
  98.         return resultList;
  99.     }
  101.     // 测量与RTT节点之间的距离
  102.     private void rangingRtt(ScanResult scanResult) {
  103.         if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
  104.             tv_result.setText("请先授予定位权限");
  105.             return;
  106.         }
  107.         RangingRequest.Builder builder = new RangingRequest.Builder();
  108.         builder.addAccessPoint(scanResult); // 添加测距入口，参数为ScanResult类型
  109. //            builder.addWifiAwarePeer(); // MacAddress类型
  110.         RangingRequest request = builder.build();
  111.         // 开始测量当前设备与指定RTT节点（路由器）之间的距离
  112.         mRttManager.startRanging(request, getMainExecutor(), new RangingResultCallback() {
  113.             // 测距失败时触发
  114.             @Override
  115.             public void onRangingFailure(int code) {
  116.                 Log.d(TAG, "RTT扫描失败，错误代码为"+code);
  117.             }
  119.             // 测距成功时触发
  120.             @Override
  121.             public void onRangingResults(List<RangingResult> results) {
  122.                 for (RangingResult result : results) {
  123.                     if (result.getStatus() == RangingResult.STATUS_SUCCESS
  124.                             && scanResult.BSSID.equals(result.getMacAddress().toString())) {
  125.                         result.getDistanceMm(); // 获取当前设备与路由器之间的距离（单位毫米）
  126.                         result.getDistanceStdDevMm(); // 获取测量偏差（单位毫米）
  127.                         result.getRangingTimestampMillis(); // 获取测量耗时（单位毫秒）
  128.                         result.getRssi(); // 获取路由器的信号
  129.                     }
  130.                 }
  131.             }
  132.         });
  133.     }
  135.     private class WifiRttReceiver extends BroadcastReceiver {
  136.         @Override
  137.         public void onReceive(Context context, Intent intent) {
  138.             if (mRttManager.isAvailable()) {
  139.                 runOnUiThread(() -> tv_result.setText("室内WiFi定位功能可以使用"));
  140.             } else {
  141.                 runOnUiThread(() -> tv_result.setText("室内WiFi定位功能不可使用"));
  142.             }
  143.         }
  144.     }
  146. }

创作不易 觉得有帮助请点赞关注收藏~~~

标签： 网络 WIFI android studio
本文转载自: https://blog.csdn.net/jiebaoshayebuhui/article/details/128104410
版权归原作者 showswoller 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Android App】检查手机连接WiFi信息以及扫描周围WiFi的讲解及实战（附源码和演示 超详细必看）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？