Java 在2个Wifi网络之间切换，连接失败

在运行Android things的Raspberry Pi 3上，我很难通过编程在两个网络之间切换（但它应该与运行普通Android相同）

第一个网络来自作为接入点的设备服务器。它运行一个FTP服务器，我需要通过它的网络访问它。据我所知，它在192.168.xxx.xxx网络中有一个静态IP地址，由WPA2-PSK保护。我知道SSID和密码是正确的。该设备位于自己的专用网络中，无法通过外部地址访问。连接到它的唯一方法是连接到它的网络并通过FTP发送到它的静态地址

第二个网络是一个开放的网络，我也知道它的SSID。这是另一个应用程序预先配置的，因此我的应用程序无法更新配置

下面的代码是我目前拥有的代码。DownloadFilesTask在我的startscreen的onCreate中调用

第一个网络的配置似乎失败了，因为将配置添加到WifiManager会返回-1作为networkId，正如我在断开和丢失所有日志之前在最后两行的日志中看到的那样。这两条线是：

04-11 11:10:51.258 1332-1349岩石、岩石、岩石、岩石、岩石、岩石

04-11:10:51.259 411-740/系统\进程I/地址更新网络：uid=10026 SSID SSID1 nid=-1

在此之后，我得到一个java.net.socketException：参数无效或无法连接并分配请求的地址

在过去的几天里，我一直在努力解决这个问题，因此，任何帮助都将不胜感激

public String connectToNetwork1() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

        if (!wifiManager.getConnectionInfo().getSSID().equals("\"" + SSID1 + "\"")) {

            WifiConfiguration conf = new WifiConfiguration();
            conf.SSID = "\"" + SSID1 + "\"";

            conf.preSharedKey = "\"" + passphrase + "\"";
            conf.allowedProtocols.set(WifiConfiguration.Protocol.RSN); // For WPA2
            conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            Log.d("connecting", conf.SSID + " " + conf.preSharedKey);

            int networkId = wifiManager.addNetwork(conf);

            Log.d("after connecting", conf.SSID + " " + conf.preSharedKey);
            wifiManager.disconnect();
            Thread t = new Thread(() -> {
                wifiManager.enableNetwork(networkId, true);                 
            });
            t.start();
            t.join();
            wifiManager.reconnect();
            Log.d("re connecting", wifiManager.getConnectionInfo().getSSID());
            return wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected to network1");
            return "already connected to network1";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "nougabollen";
}

public String connectToNetwork2() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        if (!wifiManager.getConnectionInfo().getSSID().equals("\"" + SSID2 + "\"")) {

            /*WifiConfiguration conf = new WifiConfiguration();             //
            conf.SSID = "\"" + SSID2 + "\"";                                //
                                                                            //  
            conf.status = WifiConfiguration.Status.ENABLED;                 //
            conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  // this block is useless since my application can't update this network
                                                                            // since network 2 is configured elsewhere  
            Log.d("connecting", conf.SSID);                                 //
                                                                            //
            int networkId = wifiManager.addNetwork(conf);*/                 //
            int networkId = -2;
            List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();
            for(WifiConfiguration wc : configs){
                if(wc.SSID.equals("\"" + SSID2 + "\"")){
                    networkId = wc.networkId;
                }
            }
            int finalNetworkId = networkId;
            wifiManager.disconnect();
            Thread t = new Thread(() -> {
                wifiManager.enableNetwork(finalNetworkId, true);
            });
            t.start();
            t.join();
            wifiManager.reconnect();
            Log.d("re connecting", wifiManager.getConnectionInfo().getSSID());
            return  "tried networkId: " + networkId + "   " + wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected to network2");
            return "already connected to network2";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "smoutebollen";
}

private class DownloadFilesTask extends AsyncTask<Void, Void, String> {

    @Override
    protected String doInBackground(Void... params) {
        String text = "";
        text += " " + connectToNetwork1();
        text += " " + retrieveFile();
        text += " " + connectToNetwork2();
        Log.d("text", text);
        return text;
    }

    protected void onPostExecute(String text) {
        test.setText(text);
    }
}

---

在尝试连接时出现异常，因为我没有连接到网络。

因此我设法让它工作，以下是我的工作代码。主要区别在于将WPA设置为协议，并在启用网络后让线程在我连接时休眠3秒钟

    public String connectToXs() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

        if (!wifiManager.getConnectionInfo().getSSID().equals("\"ssid\"")) {

            WifiConfiguration wc = new WifiConfiguration();
            wc.SSID = "\"ssid\"";

            wc.preSharedKey  = "\"key\"";
            wc.status = WifiConfiguration.Status.ENABLED;
            wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            wc.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            wc.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            wc.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            int res = wifiManager.addNetwork(wc);
            Log.d("WifiPreference", "add Network returned " + res );
            final boolean[] b = new boolean[1];
            Thread t = new Thread(() -> {
                b[0] = wifiManager.enableNetwork(res, true);
                wifiManager.setWifiEnabled(true);
                try {
                    Thread.sleep(3000);
                }
                catch (Exception e){
                    Log.d("ERROR",e.toString());
                }
            });
            t.start();
            t.join();
            Log.d("WifiPreference", "enableNetwork returned " + b[0]);

            return wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected");
            return "already connected";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "nougabollen";
}

public String connectToGuest() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        if (!wifiManager.getConnectionInfo().getSSID().equals("\"" + "ssid2" + "\"")) {

            //int networkId = wifiManager.addNetwork(conf);
            int networkId = -2;
            List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();
            for(WifiConfiguration wc : configs){
                if(wc.SSID.equals("\"SSID2\"")){
                    networkId = wc.networkId;
                }
            }
            int finalNetworkId = networkId;
            wifiManager.disconnect();
            Thread t = new Thread(() -> {
                wifiManager.enableNetwork(finalNetworkId, true);
                try {
                    Thread.sleep(3000);
                }
                catch (Exception e){
                    Log.d("ERROR",e.toString());
                }
            });
            t.start();
            t.join();
            wifiManager.reconnect();
            Log.d("re connecting", wifiManager.getConnectionInfo().getSSID());
            return  "tried networkId: " + networkId + "   " + wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected");
            return "already connected";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "smoutebollen";
}

公共字符串connectToXs（）{
试一试{
WifiManager WifiManager=（WifiManager）this.getApplicationContext（）.getSystemService（Context.WIFI_服务）；
如果（！wifiManager.getConnectionInfo（）.getSSID（）.equals（“\”ssid\”））{
WifiConfiguration wc=新的WifiConfiguration（）；
wc.SSID=“\”SSID\”；
wc.preSharedKey=“\”key\”；
wc.status=WifiConfiguration.status.ENABLED；
AlloweGroupCiphers.set（WifiConfiguration.GroupCipher.TKIP）；
AlloweGroupCiphers.set（WifiConfiguration.GroupCipher.CCMP）；
wc.allowedKeyManagement.set（wificonfig.keymanagement.WPA\u PSK）；
wc.allowedPairwisecipher.set（WifiConfiguration.Pairwiseciper.TKIP）；
wc.allowedPairwisecipher.set（WifiConfiguration.Pairwiseciper.CCMP）；
wc.allowedProtocols.set（WifiConfiguration.Protocol.RSN）；
wc.allowedProtocols.set（WifiConfiguration.Protocol.WPA）；
int res=wifiManager.addNetwork（wc）；
Log.d（“WifiPreference”，“添加返回的网络”+res）；
最终布尔值[]b=新布尔值[1]；
线程t=新线程（（）->{
b[0]=wifiManager.enableNetwork（res，true）；
wifiManager.setWifiEnabled（true）；
试一试{
睡眠（3000）；
}
捕获（例外e）{
Log.d（“错误”，例如toString（））；
}
});
t、 start（）；
t、 join（）；
Log.d（“WifiPreference”，“enableNetwork返回”+b[0]）；
返回wifiManager.getConnectionInfo（）.toString（）；
}否则{
日志d（“WIFI”，“已连接”）；
返回“已连接”；
}
}捕获（例外情况除外）{
Log.d（“错误”，例如toString（））；
}
返回“努加蓬”；
}
公共字符串connectToGuest（）{
试一试{
WifiManager WifiManager=（WifiManager）this.getApplicationContext（）.getSystemService（Context.WIFI_服务）；
如果（！wifiManager.getConnectionInfo（）.getSSID（）.equals（“\”+“ssid2”+“\”））{
//int networkId=wifiManager.addNetwork（conf）；
int networkId=-2；
List configs=wifiManager.getConfiguredNetworks（）；
用于（无线配置wc:configs）{
如果（wc.SSID.equals（“\”SSID2\”）{
networkId=wc.networkId；
}
}
int finalNetworkId=networkId；
wifiManager.disconnect（）；
线程t=新线程（（）->{
wifiManager.enableNetwork（finalNetworkId，true）；
试一试{
睡眠（3000）；
}
捕获（例外e）{
Log.d（“错误”，例如toString（））；
}
});
t、 start（）；
t、 join（）；
wifiManager.reconnect（）；
Log.d（“重新连接”，wifiManager.getConnectionInfo（）.getSSID（））；
返回“已尝试的网络ID:+networkId+”+wifiManager.getConnectionInfo（）.toString（）；
}否则{
日志d（“WIFI”，“已连接”）；
返回“已连接”；
}
}捕获（例外情况除外）{
Log.d（“错误”，例如toString（））；
}
返回“smoutebollen”；
}

请添加堆栈跟踪。192.168是本地网络。这意味着，如果您连接到192.168.1.1（或192.168.0.1，无论路由器地址是什么），您将访问网络上的路由器，而不是特定的路由器。如果要连接到任一网络上的特定脚本，则必须找到外部ip（使用whatsmyip.com之类的网站）。如果您的主机位于169.254范围内，则您的网络设置不起作用，任何主机都不应使用该范围。无法从DHCP服务器获取IP的设备将获取这些地址。这是我的一个错误，如果我连接到LAN网络中的设备，它将返回169.254地址，在WLAN中，它在1中有一个地址

    public String connectToXs() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

        if (!wifiManager.getConnectionInfo().getSSID().equals("\"ssid\"")) {

            WifiConfiguration wc = new WifiConfiguration();
            wc.SSID = "\"ssid\"";

            wc.preSharedKey  = "\"key\"";
            wc.status = WifiConfiguration.Status.ENABLED;
            wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            wc.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            wc.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            wc.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            wc.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            wc.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            int res = wifiManager.addNetwork(wc);
            Log.d("WifiPreference", "add Network returned " + res );
            final boolean[] b = new boolean[1];
            Thread t = new Thread(() -> {
                b[0] = wifiManager.enableNetwork(res, true);
                wifiManager.setWifiEnabled(true);
                try {
                    Thread.sleep(3000);
                }
                catch (Exception e){
                    Log.d("ERROR",e.toString());
                }
            });
            t.start();
            t.join();
            Log.d("WifiPreference", "enableNetwork returned " + b[0]);

            return wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected");
            return "already connected";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "nougabollen";
}

public String connectToGuest() {
    try {
        WifiManager wifiManager = (WifiManager) this.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        if (!wifiManager.getConnectionInfo().getSSID().equals("\"" + "ssid2" + "\"")) {

            //int networkId = wifiManager.addNetwork(conf);
            int networkId = -2;
            List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();
            for(WifiConfiguration wc : configs){
                if(wc.SSID.equals("\"SSID2\"")){
                    networkId = wc.networkId;
                }
            }
            int finalNetworkId = networkId;
            wifiManager.disconnect();
            Thread t = new Thread(() -> {
                wifiManager.enableNetwork(finalNetworkId, true);
                try {
                    Thread.sleep(3000);
                }
                catch (Exception e){
                    Log.d("ERROR",e.toString());
                }
            });
            t.start();
            t.join();
            wifiManager.reconnect();
            Log.d("re connecting", wifiManager.getConnectionInfo().getSSID());
            return  "tried networkId: " + networkId + "   " + wifiManager.getConnectionInfo().toString();
        } else {
            Log.d("WIFI", "already connected");
            return "already connected";
        }
    } catch (Exception ex) {
        Log.d("ERROR", ex.toString());
    }
    return "smoutebollen";
}