devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android获取连接到手机热点上的设备信息_android 实时显示接入wifi热点设备ip和设备名称

作者：Li_阴宅 | 2024-07-15 02:07:11

赞

踩

android 实时显示接入wifi热点设备ip和设备名称
主题：在手机开启热点网络的情况下，想要获取是哪个设备已经连接上了当前开启的热点。

实现思路：Android通过读取  /proc/net/arp 文件可以得到连接当前热点的设备信息，包括Mac地址、IP地址等信息。

方法缺陷：在某个热点网络断连后，不能实时更新已连接到的热点网络设备信息！

一. 方法逻辑：

  1.     /**
  2.      * 获取连接到手机热点上的设备信息
  3.      * @return
  4.      */
  5.     public List<HashMap> getConnectedApInfo() {
  6.         List<HashMap> connectedApInfo = new ArrayList<>();
  7.  
  8.         try {
  9.             BufferedReader br = new BufferedReader(new FileReader("/proc/net/arp"));
  10.             String line;
  11.  
  12.             while ((line = br.readLine()) != null) {
  13.                 /**
  14.                  * 获取到的数组结果，示例：[192.168.227.138, 0x1, 0x2, 82:64:5e:01:49:fc, *, wlan2]
  15.                  */
  16.                 String[] splitted = line.split(" +");
  17.                 HashMap hashMap = new HashMap();
  18.  
  19.                 //设备信息判断标准
  20.                 if (splitted.length >= 4 && splitted[3].contains(":")) {
  21.                     String ip = splitted[0];          //获取IP地址信息，代替设备名称
  22.                     String address = splitted[3];     //获取Mac地址信息
  23.  
  24.                     hashMap.put("name", ip);
  25.                     hashMap.put("address", address);
  26.  
  27.                     connectedApInfo.add(hashMap);
  28.                     Log.d(TAG, "getConnectedApInfo()，获取连接到手机热点上的设备信息：" + Arrays.toString(splitted) + "    connectedApInfo：" + connectedApInfo.size() + "  " + connectedApInfo);
  29.                 }
  30.             }
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.  
  35.         return connectedApInfo;
  36.     }
二. 拓展工具类，控制热点的开启和关闭，热点信息的获取：
  1. import static android.content.Context.CONNECTIVITY_SERVICE;
  2. import java.io.BufferedReader;
  3. import java.io.FileReader;
  4. import java.lang.reflect.InvocationHandler;
  5. import java.lang.reflect.Method;
  6. import java.util.ArrayList;
  7. import java.util.Arrays;
  8. import java.util.HashMap;
  9. import java.util.List;
  10. import android.content.ComponentName;
  11. import android.content.Context;
  12. import android.content.Intent;
  13. import android.content.pm.PackageManager;
  14. import android.content.pm.ResolveInfo;
  15. import android.net.ConnectivityManager;
  16. import android.net.wifi.WifiConfiguration;
  17. import android.net.wifi.WifiManager;
  18. import android.os.Build;
  19. import android.util.Log;
  20. import com.android.dx.stock.ProxyBuilder;
  21.  
  22. /**
  23.  * Description：控制热点的开启和关闭，热点信息的获取
  24.  * 所需权限：
  25.  * <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
  26.  * <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
  27.  * <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  28.  * <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  29.  * <uses-permission android:name="android.permission.WRITE_SETTINGS"
  30.  *     tools:ignore="ProtectedPermissions" /> <!-- 用于Android 6.0 (API 级别 23) 及以上版本 -->
  31.  */
  32. public class WifiHotspotManager {
  33.     private static final String TAG = WifiHotspotManager.class.getSimpleName();
  34.     private WifiManager wifiManager;
  35.     private Method method;
  36.  
  37.     public WifiHotspotManager(Context context) {
  38.         wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  39.     }
  40.  
  41.     public boolean isApEnabled() {
  42.         try {
  43.             if (method == null) {
  44.                 method = wifiManager.getClass().getMethod("isWifiApEnabled");
  45.             }
  46.             return (boolean) method.invoke(wifiManager);
  47.         } catch (Exception e) {
  48.             Log.e(TAG, "Error checking if AP is enabled", e);
  49.             return false;
  50.         }
  51.     }
  52.  
  53.     /**
  54.      * 开启或关闭热点
  55.      * @param enabled
  56.      * @return
  57.      */
  58.     public boolean setApEnabled(boolean enabled) {
  59.         if (enabled) {
  60.             Log.d(TAG, "开启热点，Enabling hotspot");
  61.         } else {
  62.             Log.d(TAG, "关闭热点，Disabling hotspot");
  63.         }
  64.  
  65.         try {
  66.             if (method == null) {
  67.                 method = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
  68.             }
  69.             return (boolean) method.invoke(wifiManager, null, enabled);
  70.         } catch (Exception e) {
  71.             Log.e(TAG, "开启或关闭热点 is error，enabling/disabling AP：" + e);
  72.             return false;
  73.         }
  74.     }
  75.  
  76.     /**
  77.      * 配置热点的设置（如SSID和密码）
  78.      * 需要创建一个WifiConfiguration对象来配置你的热点设置，然后将其传递给configureApState方法
  79.      * @param apConfig
  80.      * @return
  81.      */
  82.     public boolean configureApState(WifiConfiguration apConfig) {
  83.         try {
  84.             Method method = wifiManager.getClass().getMethod("setWifiApConfiguration", WifiConfiguration.class);
  85.             return (boolean) method.invoke(wifiManager, apConfig);
  86.         } catch (Exception e) {
  87.             Log.e(TAG, "Error setting AP configuration", e);
  88.             return false;
  89.         }
  90.     }
  91.  
  92.     /**
  93.      * 控制热点的开启和关闭（一步到位）
  94.      */
  95.     public boolean controlApSwitch(Context context, boolean flag){
  96.         WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  97.         try{
  98.             WifiConfiguration apConfig = new WifiConfiguration();
  99.             String deviceModel = Build.MODEL;     //设备型号
  100.             apConfig.SSID = deviceModel;          //配置热点的名称
  101.             apConfig.preSharedKey = "12345678";   //配置热点的密码(至少8位)
  102.             apConfig.allowedKeyManagement.set(4); //配置密码加密方式
  103.  
  104.             //通过反射调用设置热点
  105.             Method method = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
  106.             Boolean rs = (Boolean) method.invoke(wifiManager, apConfig, flag);        //true 开启热点 ，false 关闭热点
  107.             Log.d(TAG, flag ? "当前设备：" + deviceModel + " 开启热点网络是否成功:" + rs : " 关闭热点网络是否成功:" + rs);
  108.             return rs;
  109.         } catch(Exception e){
  110.             e.printStackTrace();
  111.             return false;
  112.         }
  113.     }
  114.  
  115.  
  116.     /**
  117.      * 发送隐式广播。此方法会查询与给定意图相匹配的所有广播接收器，并向每个匹配的接收器发送一个显式广播。
  118.      *
  119.      * @param context 上下文，用于发送广播。
  120.      * @param intent 需要发送的隐式广播意图。
  121.      * @param action 执行的动作
  122.      */
  123.     public void sendImplicitBroadcast(Context context, Intent intent, String action) {
  124.         // 获取包管理器，用于查询广播接收器
  125.         PackageManager pm = context.getPackageManager();
  126.         // 查询与intent相匹配的所有广播接收器
  127.         List<ResolveInfo> matches = pm.queryBroadcastReceivers(intent, 0);
  128.  
  129.         // 遍历所有匹配的广播接收器
  130.         for (ResolveInfo resolveInfo : matches) {
  131.             // 创建一个新的意图，将其转换为显式意图，目标为当前接收器
  132.             Intent explicit = new Intent(intent);
  133.             // 设置组件名称，转换为显式意图
  134.             ComponentName cn = new ComponentName(resolveInfo.activityInfo.applicationInfo.packageName, resolveInfo.activityInfo.name);
  135.             explicit.setComponent(cn);
  136.             // 向每个匹配的广播接收器发送显式广播
  137.             context.sendBroadcast(explicit);
  138.         }
  139.  
  140.         Log.d(TAG, "sendImplicitBroadcast()，发送隐式广播，action：" + action);
  141.     }
  142.  
  143.     /**
  144.      * 打开手机的热点
  145.      * 需要在build.gradle文件添加三方库依赖：implementation 'com.linkedin.dexmaker:dexmaker-mockito:2.12.1'
  146.      * @param context
  147.      */
  148.     public void startTethering(Context context){
  149.         ConnectivityManager connectivityManager = ((ConnectivityManager)context.getSystemService(CONNECTIVITY_SERVICE));
  150.         try{
  151.             Class classOnStartTetheringCallback = Class.forName("android.net.ConnectivityManager$OnStartTetheringCallback");
  152.             Method startTethering=connectivityManager.getClass().getDeclaredMethod("startTethering",int.class,boolean.class,classOnStartTetheringCallback);
  153.             Object proxy = ProxyBuilder.forClass(classOnStartTetheringCallback).handler(new InvocationHandler(){
  154.                 @Override
  155.                 public Object invoke(Object o,Method method,Object[]objects)throws Throwable{
  156.                     return null;
  157.                 }
  158.             }).build();
  159.             startTethering.invoke(connectivityManager,0,false,proxy);
  160.         } catch(Exception e){
  161.             e.printStackTrace();
  162.         }
  163.  
  164.         Log.d(TAG, "startTethering()，打开手机的热点");
  165.     }
  166.  
  167.     /**
  168.      * 关闭手机的热点
  169.      */
  170.     public void stopTethering(Context context){
  171.         ConnectivityManager connectivityManager=((ConnectivityManager)context.getSystemService(CONNECTIVITY_SERVICE));
  172.         try{
  173.             Method stopTethering = connectivityManager.getClass().getDeclaredMethod("stopTethering",int.class);
  174.             stopTethering.invoke(connectivityManager,0);
  175.         }catch(Exception e){
  176.             e.printStackTrace();
  177.         }
  178.         Log.d(TAG, "stopTethering()，关闭手机的热点");
  179.     }
  180.  
  181.     /**
  182.      * 判断是否开启手机的热点
  183.      * @param context
  184.      * @return
  185.      */
  186.     public boolean isWifiApEnabled(Context context){
  187.         WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(
  188.                 Context.WIFI_SERVICE);
  189.         try{
  190.             Method method=wifiManager.getClass().getMethod("isWifiApEnabled");
  191.             method.setAccessible(true);
  192.             return(Boolean)method.invoke(wifiManager);
  193.         }catch(NoSuchMethodException e){
  194.             e.printStackTrace();
  195.         }catch(Exception e){
  196.             e.printStackTrace();
  197.         }
  198.  
  199.         Log.d(TAG, "isWifiApEnabled()，判断是否开启手机的热点");
  200.         return false;
  201.     }
  202.  
  203.     /**
  204.      * 获取手机的热点信息
  205.      * @param context
  206.      * @return
  207.      */
  208.     public String getApInfo(Context context){
  209.         WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  210.         try{
  211.             Method localMethod = wifiManager.getClass().getDeclaredMethod("getWifiApConfiguration", new Class[0]);
  212.             Object config = localMethod.invoke(wifiManager);
  213.             Log.d(TAG, "getApInfo()，获取手机的热点信息：" + config.toString());
  214.         }catch(Exception localException){
  215.             localException.printStackTrace();
  216.         }
  217.         return null;
  218.     }
  219.  
  220.     /**
  221.      * 获取连接到手机热点上的设备信息
  222.      * @return
  223.      */
  224.     public List<HashMap> getConnectedApInfo() {
  225.         List<HashMap> connectedApInfo = new ArrayList<>();
  226.  
  227.         try {
  228.             BufferedReader br = new BufferedReader(new FileReader("/proc/net/arp"));
  229.             String line;
  230.  
  231.             while ((line = br.readLine()) != null) {
  232.                 /**
  233.                  * 获取到的数组结果，示例：[192.168.227.138, 0x1, 0x2, 82:64:5e:01:49:fc, *, wlan2]
  234.                  */
  235.                 String[] splitted = line.split(" +");
  236.                 HashMap hashMap = new HashMap();
  237.  
  238.                 //设备信息判断标准
  239.                 if (splitted.length >= 4 && splitted[3].contains(":")) {
  240.                     String ip = splitted[0];          //获取IP地址信息，代替设备名称
  241.                     String address = splitted[3];     //获取Mac地址信息
  242.  
  243.                     hashMap.put("name", ip);
  244.                     hashMap.put("address", address);
  245.  
  246.                     connectedApInfo.add(hashMap);
  247.                     Log.d(TAG, "getConnectedApInfo()，获取连接到手机热点上的设备信息：" + Arrays.toString(splitted) + "    connectedApInfo：" + connectedApInfo.size() + "  " + connectedApInfo);
  248.                 }
  249.             }
  250.         } catch (Exception e) {
  251.             e.printStackTrace();
  252.         }
  253.  
  254.         return connectedApInfo;
  255.     }
三. 调用示例：
  1. //返回的是一个数据形式是包含HahMap集合的List集合，可根据HashMap的键值对取值并显示
  2. WifiHotspotManager wifiHotspotManager = new WifiHotspotManager(requireActivity());
  3.  
  4. List<HashMap> connectedApInfo = wifiHotspotManager.getConnectedApInfo();
  5.  
  6. Log.d(TAG, "connectedApInfo：" + connectedApInfo.size() + "  " + connectedApInfo);
四.手机热点已连接设备与功能效果图

参考文章：Android获取实时连接热点的设备IP_安卓设备获取ip-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/827363
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号