强制Android应用程序连接到特定的WiFi网络

我正在构建一个连接到某个无法访问互联网的WiFi网络的应用程序，我通过该应用程序（而不是通过设置）添加了网络配置，因此我可以启用/禁用该网络

该应用程序的工作原理如下：

1-用户按下按钮

2-我检查WiFi是否已启用，如果未启用，我将启用它。 此外，如果手机已经连接到WiFi网络，我会将其从该网络断开，然后连接到我的手机（这很好）

3-I使用以下方法连接网络（启用WiFi后）：

但是，如果WiFi最初被禁用，WiFi被启用，但并不总是连接到我的网络，它有时会连接到其他配置的网络（如果可用），这似乎不起作用

我试着给我的网络一个高优先级（高于所有其他配置的网络），但没有任何区别

在启用WiFi之前，我也尝试启用网络，但没有成功

我尝试添加一个mWifiManager.disconnect（）；但是没有变化

mWifiManager.disonnect();
mWifiManager.enableNetwork(networkId, true);
mWifiManager.reconnect();

所以我有一些问题：

Q1当您已经连接到WiFi网络时，但如果WiFi被禁用，它为什么会工作

问题2：有没有有效的方法来强制应用程序连接到特定的网络？（我正在使用Android 7.0 API 24）

这是我的密码：

int mID;
String mSSID;
String mPASSWORD;
public void connectToWiFi(String ssid, String key) {
    mSSID = ssid;
    mPASSWORD = key;
    if (!mWifiManager.isWifiEnabled()) {
        WifiUtils.withContext(mContext).enableWifi(this::enableResult);
        //Also tried 
       // boolean wifiEnabled = mWifiManager.setWifiEnabled(true);
      return;
    }
    connectToNetwork();
}

private void enableResult(boolean b) { //This is to make sure WiFi has been enabled successfully
    Log.w(TAG, "enableResult:" + b);

    if (b) {
        connectToNetwork();
    }
}

private void connectToNetwork() {
    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);// also tried to store the id in shared prefs and get it back here (did not work for me)
    mID = getExistingNetworkId(mSSID);
    if (mID == -1) {//Network has not been configured yet, so I add it
        mID = addNetworkToConfiguration();
        MyApplication.getInstance().getShared().setNetowrkID(mID);// store the id in shred prefs 
        mWifiManager.saveConfiguration();
    }
    boolean disconnect = mWifiManager.disconnect();
    boolean result = mWifiManager.enableNetwork(mID, true);
    boolean reconnect = mWifiManager.reconnect();
}

private int addNetworkToConfiguration() {
    WifiConfiguration config = new WifiConfiguration();
    config.SSID = quoted(mSSID);
    config.status = WifiConfiguration.Status.ENABLED;
    config.preSharedKey = quoted(mPASSWORD);
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
    config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
    assignHighestPriority(config);
    return mWifiManager.addNetwork(config);
 }

 private int getExistingNetworkId(String SSID) {
    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
    List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
    if (configuredNetworks != null) {
        for (WifiConfiguration existingConfig : configuredNetworks) {
            if (areEqual(trimQuotes(existingConfig.SSID), trimQuotes(SSID))) {
                return existingConfig.networkId;
            }
        }
    }else {
        Log.e(TAG,"Unable to fetch network configurations");
    }
    return -1;}
private void assignHighestPriority(WifiConfiguration config) {
    List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
    if (configuredNetworks != null) {
        for (WifiConfiguration existingConfig : configuredNetworks) {
            if (config.priority <= existingConfig.priority) {
                config.priority = existingConfig.priority + 1;
            }
        }
    }
}

int-mID；
字符串mSSID；
字符串mPASSWORD；
public void connectToWiFi（字符串ssid，字符串键）{
mSSID=ssid；
mPASSWORD=关键字；
如果（！mWifiManager.isWifiEnabled（））{
WifiUtils.withContext（mContext）.enableWifi（this:：enableResult）；
//也试过
//布尔值wifiEnabled=mWifiManager.setWifiEnabled（true）；
返回；
}
connectToNetwork（）；
}
private void enableResult（布尔b）{//这是为了确保已成功启用WiFi
Log.w（标签“enableResult:+b”）；
如果（b）{
connectToNetwork（）；
}
}
私有void connectToNetwork（）{
mWifiManager=（WifiManager）mContext.getSystemService（Context.WIFI_SERVICE）；//还尝试将id存储在共享pref中并返回此处（对我无效）
mID=getExistingNetworkId（mSSID）；
如果（mID==-1）{//Network尚未配置，那么我添加它
mID=将网络添加到配置（）；
MyApplication.getInstance（）.getShared（）.setNetowrkID（mID）；//将id存储在shred prefs中
mWifiManager.saveConfiguration（）；
}
布尔disconnect=mWifiManager.disconnect（）；
布尔结果=mWifiManager.enableNetwork（mID，true）；
boolean reconnect=mWifiManager.reconnect（）；
}
私有int addNetworkToConfiguration（）{
WifiConfiguration config=新的WifiConfiguration（）；
config.SSID=引用（mSSID）；
config.status=WifiConfiguration.status.ENABLED；
config.preSharedKey=quoted（mPASSWORD）；
config.allowedKeyManagement.set（WifiConfiguration.KeyMgmt.WPA\u PSK）；
config.alloweGroupCiphers.set（WifiConfiguration.GroupCipher.TKIP）；
config.alloweGroupCiphers.set（WifiConfiguration.GroupCipher.CCMP）；
config.allowedPairwiseCiphers.set（WifiConfiguration.PairwiseCipher.TKIP）；
config.allowedPairwiseCiphers.set（WifiConfiguration.PairwiseCipher.CCMP）；
config.allowedProtocols.set（WifiConfiguration.Protocol.RSN）；
config.allowedProtocols.set（WifiConfiguration.Protocol.WPA）；
分配最高优先级（配置）；
返回mWifiManager.addNetwork（配置）；
}
私有int getExistingNetworkId（字符串SSID）{
mWifiManager=（WifiManager）mContext.getSystemService（Context.WIFI_服务）；
List configuredNetworks=mWifiManager.getConfiguredNetworks（）；
if（configuredNetworks！=null）{
对于（现有的WifiConfiguration-existingConfig:configuredNetworks）{
if（等于（trimQuotes（existingConfig.SSID），trimQuotes（SSID）））{
返回existingConfig.networkId；
}
}
}否则{
Log.e（标记“无法获取网络配置”）；
}
返回-1；}
最高优先级（无线配置配置）{
List configuredNetworks=mWifiManager.getConfiguredNetworks（）；
if（configuredNetworks！=null）{
对于（现有的WifiConfiguration-existingConfig:configuredNetworks）{
如果（config.priorityQ1），我认为您必须将此指令添加到代码中，以便重新启用wifi：
mWifiManager.setWifiEnabled（true）；

问题2）除了您发布的方法外，我不知道如何强制使用wifi
您找到解决方案了吗？
int mID;
String mSSID;
String mPASSWORD;
public void connectToWiFi(String ssid, String key) {
    mSSID = ssid;
    mPASSWORD = key;
    if (!mWifiManager.isWifiEnabled()) {
        WifiUtils.withContext(mContext).enableWifi(this::enableResult);
        //Also tried 
       // boolean wifiEnabled = mWifiManager.setWifiEnabled(true);
      return;
    }
    connectToNetwork();
}

private void enableResult(boolean b) { //This is to make sure WiFi has been enabled successfully
    Log.w(TAG, "enableResult:" + b);

    if (b) {
        connectToNetwork();
    }
}

private void connectToNetwork() {
    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);// also tried to store the id in shared prefs and get it back here (did not work for me)
    mID = getExistingNetworkId(mSSID);
    if (mID == -1) {//Network has not been configured yet, so I add it
        mID = addNetworkToConfiguration();
        MyApplication.getInstance().getShared().setNetowrkID(mID);// store the id in shred prefs 
        mWifiManager.saveConfiguration();
    }
    boolean disconnect = mWifiManager.disconnect();
    boolean result = mWifiManager.enableNetwork(mID, true);
    boolean reconnect = mWifiManager.reconnect();
}

private int addNetworkToConfiguration() {
    WifiConfiguration config = new WifiConfiguration();
    config.SSID = quoted(mSSID);
    config.status = WifiConfiguration.Status.ENABLED;
    config.preSharedKey = quoted(mPASSWORD);
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
    config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
    assignHighestPriority(config);
    return mWifiManager.addNetwork(config);
 }

 private int getExistingNetworkId(String SSID) {
    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
    List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
    if (configuredNetworks != null) {
        for (WifiConfiguration existingConfig : configuredNetworks) {
            if (areEqual(trimQuotes(existingConfig.SSID), trimQuotes(SSID))) {
                return existingConfig.networkId;
            }
        }
    }else {
        Log.e(TAG,"Unable to fetch network configurations");
    }
    return -1;}
private void assignHighestPriority(WifiConfiguration config) {
    List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
    if (configuredNetworks != null) {
        for (WifiConfiguration existingConfig : configuredNetworks) {
            if (config.priority <= existingConfig.priority) {
                config.priority = existingConfig.priority + 1;
            }
        }
    }
}