Android WiFi热点管理与状态监听技术说明

创建WiFi热点

在Android系统中创建WiFi热点的实现步骤如下：

获取WiFi管理服务：首先通过反射机制获取WiFiManager实例，这将是我们进行热点配置和操作的主要工具。

配置热点参数：创建一个WifiConfiguration对象，并填充必要的参数：

SSID：热点的名称，可以是任意字符串。

密码：热点的安全访问密钥，支持PSK认证模式。

网络协议：配置支持的网络协议以确保热点兼容性。

加密算法：设置允许的加密算法，以确保连接的安全性。

创建热点：通过反射调用WiFiManager的setWifiApEnabled方法，传递配置参数，开启热点功能。需要注意的是，Android系统要求WiFi和热点不能同时打开，因此在开启热点前需要先确保WiFi已关闭。

热点状态管理：通过反射调用相应的方法来控制热点的开启和关闭状态。例如，isWifiApEnabled方法可以用于检查热点是否已开启。

热点状态监听

为了实现对WiFi热点状态的实时监听，可以使用广播接收器和观察者模式：

注册广播接收器：在Android服务中注册一个广播接收器，监听android.net.wifi.WIFI_AP_STATE_CHANGED事件。该事件提供了热点的状态信息，状态值为：

10：热点正在关闭

11：热点已关闭

12：热点正在开启

13：热点已开启

服务模式实现：将状态监听逻辑封装到一个服务中，通过注册动作接收器实现长期运行。服务可以根据收到状态变化事件，触发相应的业务逻辑。

状态更新通知：通过观察者模式，将热点状态变化通知到所有注册的监听器，确保多个组件能够实时获取状态信息。

代码示例

// WiFi热点工具类
public class WifiHotUtil {
    private WifiManager mWifiManager;
    private Context mContext;
    public WifiHotUtil(Context context) {
        mContext = context;
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    }
    // 启用热点
    public void startWifiAp(String ssid, String passwd) {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
        if (!isWifiApEnabled()) {
            stratWifiAp(ssid, passwd);
        }
    }
    // 热点配置
    private void stratWifiAp(String mSSID, String mPasswd) {
        try {
            Method method = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
            WifiConfiguration netConfig = new WifiConfiguration();
            netConfig.SSID = mSSID;
            netConfig.preSharedKey = mPasswd;
            netConfig.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
            netConfig.allowedProtocols.set(Protocol.RSN);
            netConfig.allowedProtocols.set(Protocol.WPA);
            netConfig.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
            netConfig.allowedPairwiseCiphers.set(PairwiseCipher.CCMP);
            netConfig.allowedPairwiseCiphers.set(PairwiseCipher.TKIP);
            netConfig.allowedGroupCiphers.set(GroupCipher.CCMP);
            netConfig.allowedGroupCiphers.set(GroupCipher.TKIP);
            method.invoke(mWifiManager, netConfig, true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 检查热点状态
    public boolean isWifiApEnabled() {
        try {
            Method method = mWifiManager.getClass().getMethod("isWifiApEnabled");
            method.setAccessible(true);
            return (Boolean) method.invoke(mWifiManager);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    // 关闭热点
    public void closeWifiAp() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        if (isWifiApEnabled()) {
            try {
                Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
                method.setAccessible(true);
                WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
                Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
                method2.invoke(wifiManager, config, false);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}
// 热点状态监听接口
public interface WiFiAPListener {
    public static final int WIFI_AP_CLOSEING = 10;  // 热点正在关闭
    public static final int WIFI_AP_CLOSE_SUCCESS = 11;  // 热点关闭成功
    public static final int WIFI_AP_OPENING = 12;  // 热点正在开启
    public static final int WIFI_AP_OPEN_SUCCESS = 13;  // 热点开启成功
    public void stateChanged(int state);
}
// 热点状态监听器
public class WiFiAPObserver implements WiFiAPListener {
    private HashSet
   
     listenerSet = new HashSet<>();
    public void addWiFiAPListener(WifiAPListener listener) {
        if (!listenerSet.contains(listener)) {
            listenerSet.add(listener);
        }
    }
    public void removeWiFiAPListener(WifiAPListener listener) {
        if (listenerSet.contains(listener)) {
            listenerSet.remove(listener);
        }
    }
    public void clearWiFiAPListener() {
        listenerSet.clear();
    }
    @Override
    public void stateChanged(int state) {
        for (WiFiAPListener listener : listenerSet) {
            listener.stateChanged(state);
        }
    }
}
// 热点状态监听服务
public class WiFiAPService extends Service {
    private static final String TAG = "WiFiAPService";
    private static final String ACTION_START_SERVICE = "action_start_service";
    private static final String ACTION_STOP_SERVICE = "action_stop_service";
    private static WiFiAPObserver wiFiAPObserver = new WiFiAPObserver();
    public static void startService(Context context) {
        Intent intent = new Intent(context, WiFiAPService.class);
        intent.setAction(ACTION_START_SERVICE);
        context.startService(intent);
    }
    public static void stopService(Context context) {
        Intent intent = new Intent(context, WiFiAPService.class);
        intent.setAction(ACTION_STOP_SERVICE);
        context.startService(intent);
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        if (intent.getAction().equals(ACTION_START_SERVICE)) {
            // 开始监听热点状态
            registerReceiver(wifiReceiver, new IntentFilter("android.net.wifi.WIFI_AP_STATE_CHANGED"));
        } else if (intent.getAction().equals(ACTION_STOP_SERVICE)) {
            stopSelf();
        }
        return START_REDELIVER_INTENT;
    }
    @Override
    public void onCreate() {
        registerReceiver(wifiReceiver, new IntentFilter("android.net.wifi.WIFI_AP_STATE_CHANGED"));
        super.onCreate();
    }
    @Override
    public void onDestroy() {
        unregisterReceiver(wifiReceiver);
        wiFiAPObserver.clearWiFiAPListener();
        super.onDestroy();
    }
    private BroadcastReceiver wifiReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if ("android.net.wifi.WIFI_AP_STATE_CHANGED".equals(action)) {
                int state = intent.getIntExtra("wifi_state", 0);
                Log.i(TAG, "state= " + state);
                wiFiAPObserver.stateChanged(state);
            }
        }
    };
}

使用说明

工具类使用：

WifiHotUtil wifiHotUtil = new WifiHotUtil(this);
wifiHotUtil.startWifiAp("hotspot", "password");
// 关闭热点
wifiHotUtil.closeWifiAp();

服务监听：在WiFiAPService中注册状态监听器，并在需要的时候启动服务：

WiFiAPService.startService(this);

状态通知：实现WiFiAPListener接口，注册到服务中，接收状态变化通知：

WiFiAPService.addWiFiAPListener(this);

通过以上方法，可以实现WiFi热点的创建、关闭以及状态监听，满足便携设备之间的文件传输需求。

转载地址：http://wvwp.baihongyu.com/

你可能感兴趣的文章