通过编程方式连接到Android Q中的Wifi

我有这个功能可以在Wifi网络中连接，在Android 10下可以正常工作，但是当我在Android 10上尝试时，我成功连接了，但是没有互联网，，我知道是的，但我发现这个功能可以从Android 10连接到Wifi，没有问题。 我被封锁了好几天

我的职能：

private void connectToWifi(String ssid, String password)
    {
        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            try {
                Log.e(TAG,"connection wifi pre Q");
                WifiConfiguration wifiConfig = new WifiConfiguration();
                wifiConfig.SSID = "\"" + ssid + "\"";
                wifiConfig.preSharedKey = "\"" + password + "\"";
                int netId = wifiManager.addNetwork(wifiConfig);
                wifiManager.disconnect();
                wifiManager.enableNetwork(netId, true);
                wifiManager.reconnect();

            } catch ( Exception e) {
                e.printStackTrace();
            }
        } else {
            Log.e(TAG,"connection wifi  Q");

            WifiNetworkSpecifier wifiNetworkSpecifier = new WifiNetworkSpecifier.Builder()
                .setSsid( ssid )
                .setWpa2Passphrase(password)
                    .build();

            NetworkRequest networkRequest = new NetworkRequest.Builder()
                    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                    .setNetworkSpecifier(wifiNetworkSpecifier)
                    .build();

             connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);


                 networkCallback = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    super.onAvailable(network);

                     connectivityManager.bindProcessToNetwork(network);
                    Log.e(TAG,"onAvailable");
                }

                  @Override
                  public void onLosing(@NonNull Network network, int maxMsToLive) {
                      super.onLosing(network, maxMsToLive);
                      Log.e(TAG,"onLosing");
                  }

                  @Override
                public void onLost(Network network) {
                    super.onLost(network);
                    Log.e(TAG, "losing active connection");
                }

                @Override
                public void onUnavailable() {
                    super.onUnavailable();
                    Log.e(TAG,"onUnavailable");
                }
            };
            connectivityManager.requestNetwork(networkRequest,networkCallback);


        }
    }

private void connectToWifi（字符串ssid，字符串密码）
{
WifiManager WifiManager=（WifiManager）getSystemService（WIFI_服务）；
if（Build.VERSION.SDK_INT

如果你想通过互联网连接到WiFi，你应该使用这种网络请求：

此外，您需要为您的进程指定默认路由，以便永久向已连接的WiFi AP发出请求。只需将下一个方法的调用添加到OnAvailable下的NetworkCallback，如下所示：

networkCallback = new ConnectivityManager.NetworkCallback() {
    @Override
    public void onAvailable(Network network) {
        createNetworkRoute(network, connectivityManager);
        }
    };
    if (connectivityManager!= null) connectivityManager.requestNetwork(request, networkCallback);

不要忘记断开与绑定网络的连接：

connectivityManager.unregisterNetworkCallback(networkCallback);

最后，您可以在不同的库中找到最佳实践，如。

如果您具有root访问权限（adb root）：

手动连接到您选择的Wifi网络

拉取这些ADB文件：

保存在指定Wifi网络的文件夹中：

复制到您选择的位置不要更改您提取的文件的名称。

无论何时您想要连接到所需的wifi网络：

adb推送\WifiConfigStore.xml/data/misc/wifi/
adb push\WifiConfigStore.xml.encrypted-checksum/data/misc/wifi/
亚洲开发银行重启

您可以尝试api，我可以使用它们进行连接

final WifiNetworkSuggestion suggestion1 =
            new WifiNetworkSuggestion.Builder()
                    .setSsid("YOUR_SSID")
                    .setWpa2Passphrase("YOUR_PRE_SHARED_KEY")
                    .build();
    final List<WifiNetworkSuggestion> suggestionsList =
            new ArrayList<WifiNetworkSuggestion>();
    suggestionsList.add(suggestion1);

    WifiManager wifiManager =
            (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    int status = wifiManager.addNetworkSuggestions(suggestionsList);
    if (status == 0 ){
        Toast.makeText(this,"PSK network added",Toast.LENGTH_LONG).show();
        Log.i(TAG, "PSK network added: "+status);
    }else {
        Toast.makeText(this,"PSK network not added",Toast.LENGTH_LONG).show();
        Log.i(TAG, "PSK network not added: "+status);
    }

最终wifinetworks建议1=
新的WifiNetworkSuggestion.Builder（）
.setSsid（“您的_SSID”）
.setWpa2Passphrase（“您的共享密钥”）
.build（）；
最终列表建议列表=
新的ArrayList（）；
建议列表。添加（建议1）；
wifi经理wifi经理=
（WifiManager）getApplicationContext（）.getSystemService（Context.WIFI_服务）；
int status=wifiManager.addNetworkSuggestions（建议列表）；
如果（状态==0）{
Toast.makeText（这是“添加了PSK网络”，Toast.LENGTH_LONG.show（）；
Log.i（标签，“添加PSK网络：”+状态）；
}否则{
Toast.makeText（这是“未添加PSK网络”，Toast.LENGTH_LONG.show（）；
Log.i（标签，“未添加PSK网络：”+状态）；
}

因此，我的解决方案是使用targetSdkVersion 28编译你的应用程序。 要连接到wifi，请使用此功能

connectToWifi(String ssid, String key)

目前这只是一个解决办法，等待谷歌发布此漏洞的修复程序，有关更多信息，请参阅向谷歌报告的问题：

---

}

到目前为止，在我测试过的大多数设备上，什么对我有效，有一个回退选项，至少可以停止可怕的“循环请求”，并允许成功的手动连接

下面的代码是用Kotlin编写的，如果需要，请用谷歌搜索如何转换为Java

创建API>=29所需的NetworkCallback（以前不需要，但可以使用）

按如下方式连接到网络：

val wifiNetworkSpecifier = WifiNetworkSpecifier.Builder()
    .setSsid(ssid)
    .setWpa2Passphrase(pass)
    .build()

val networkRequest = NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
// Add the below 2 lines if the network should have internet capabilities.
// Adding/removing other capabilities has made no known difference so far
//    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
//    .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
    .setNetworkSpecifier(wifiNetworkSpecifier)
    .build()

connectivityManager.requestNetwork(networkRequest, networkCallback)

如上所述，一些OEM ROM没有“保留请求”，因此连接会立即中断。OnePlus已在其一些较新型号中修复了此问题，但并非全部。此漏洞将持续存在于某些Android版本的某些手机型号中，因此需要成功的回退（即，无网络中断的手动连接）。没有已知的解决方法可用，但如果找到，我将在此处作为一个选项进行更新

要删除网络，请执行以下操作：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    //This is required for Xiaomi models for disconnecting
    connectivityManager.bindProcessToNetwork(null)
} else {
    connectivityManager.setProcessDefaultNetwork(null)
}
connectivityManager.unregisterNetworkCallback(it)

请记住，自动连接允许自动和手动断开连接

adb push <location>\WifiConfigStore.xml /data/misc/wifi/
adb push <location>\WifiConfigStore.xml.encrypted-checksum /data/misc/wifi/

adb reboot

final WifiNetworkSuggestion suggestion1 =
            new WifiNetworkSuggestion.Builder()
                    .setSsid("YOUR_SSID")
                    .setWpa2Passphrase("YOUR_PRE_SHARED_KEY")
                    .build();
    final List<WifiNetworkSuggestion> suggestionsList =
            new ArrayList<WifiNetworkSuggestion>();
    suggestionsList.add(suggestion1);

    WifiManager wifiManager =
            (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    int status = wifiManager.addNetworkSuggestions(suggestionsList);
    if (status == 0 ){
        Toast.makeText(this,"PSK network added",Toast.LENGTH_LONG).show();
        Log.i(TAG, "PSK network added: "+status);
    }else {
        Toast.makeText(this,"PSK network not added",Toast.LENGTH_LONG).show();
        Log.i(TAG, "PSK network not added: "+status);
    }

connectToWifi(String ssid, String key)

public void connectToWifi(String ssid, String key) {

Log.e(TAG, "connection wifi pre Q");
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.SSID = "\"" + ssid + "\"";
wifiConfig.preSharedKey = "\"" + key + "\"";
int netId = wifiManager.addNetwork(wifiConfig);
if (netId == -1) netId = getExistingNetworkId(wifiConfig.SSID);

wifiManager.disconnect();
wifiManager.enableNetwork(netId, true);
wifiManager.reconnect();

val networkCallback = object : ConnectivityManager.NetworkCallback() {
    override fun onAvailable(network: Network) {
        super.onAvailable(network)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // To make sure that requests don't go over mobile data
            connectivityManager.bindProcessToNetwork(network)
        } else {
            connectivityManager.setProcessDefaultNetwork(network)
        }
    }

    override fun onLost(network: Network) {
        super.onLost(network)
        // This is to stop the looping request for OnePlus & Xiaomi models
        connectivityManager.bindProcessToNetwork(null)
        connectivityManager.unregisterNetworkCallback(networkCallback)
        // Here you can have a fallback option to show a 'Please connect manually' page with an Intent to the Wifi settings
    }
}

val wifiNetworkSpecifier = WifiNetworkSpecifier.Builder()
    .setSsid(ssid)
    .setWpa2Passphrase(pass)
    .build()

val networkRequest = NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
// Add the below 2 lines if the network should have internet capabilities.
// Adding/removing other capabilities has made no known difference so far
//    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
//    .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
    .setNetworkSpecifier(wifiNetworkSpecifier)
    .build()

connectivityManager.requestNetwork(networkRequest, networkCallback)

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    //This is required for Xiaomi models for disconnecting
    connectivityManager.bindProcessToNetwork(null)
} else {
    connectivityManager.setProcessDefaultNetwork(null)
}
connectivityManager.unregisterNetworkCallback(it)

private ConnectivityManager mConnectivityManager;

@Override
    public void onCreate(@Nullable Bundle savedInstanceState){
// instantiate the connectivity manager
        mConnectivityManager = (ConnectivityManager) this.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);

}

public void connect(String ssid, String password) {
        NetworkSpecifier networkSpecifier  = new WifiNetworkSpecifier.Builder()
                  .setSsid(ssid)
                  .setWpa2Passphrase(password)
                  .setIsHiddenSsid(true) //specify if the network does not broadcast itself and OS must perform a forced scan in order to connect
                  .build();
        NetworkRequest networkRequest  = new NetworkRequest.Builder()
                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                .setNetworkSpecifier(networkSpecifier)
                .build();
        mConnectivityManager.requestNetwork(networkRequest, mNetworkCallback);
    }
    
    public void disconnectFromNetwork(){
        //Unregistering network callback instance supplied to requestNetwork call disconnects phone from the connected network
        mConnectivityManager.unregisterNetworkCallback(mNetworkCallback);
    }
    
    private ConnectivityManager.NetworkCallback mNetworkCallback = new ConnectivityManager.NetworkCallback(){
            @Override
            public void onAvailable(@NonNull Network network) {
                super.onAvailable(network);
                //phone is connected to wifi network
            }
    
            @Override
            public void onLosing(@NonNull Network network, int maxMsToLive) {
                super.onLosing(network, maxMsToLive);
                //phone is about to lose connection to network
            }
    
            @Override
            public void onLost(@NonNull Network network) {
                super.onLost(network);
                //phone lost connection to network
            }
    
            @Override
            public void onUnavailable() {
                super.onUnavailable();
                //user cancelled wifi connection
            }
        };

startActivity(new Intent("android.settings.panel.action.INTERNET_CONNECTIVITY"))