知道Wi-Fi名称和密码之后自动连接
这里写自定义目录标题
- 有Wi-Fi名称和密码自动连接Wi-Fi
-
-
- 主Activity
- 服务类 WIFIStateReceiver
- 工具类 WIFIConnectionManager
-
有Wi-Fi名称和密码自动连接Wi-Fi
主Activity
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private static final String TAG = MainActivity.class.getName();
private EditText mEtAccount;
private EditText mEtPwd;
private WIFIStateReceiver mWIFIStateReceiver;
private Button mBtnAuto;
private Button mBtnDisconnect;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
initData();
initEvent();
}
private void initEvent() {
mBtnAuto.setOnClickListener(this);
mBtnDisconnect.setOnClickListener(this);
}
private void initData() {
}
private void initView() {
mEtAccount = findViewById(R.id.et_account);
mEtPwd = findViewById(R.id.et_pwd);
mBtnAuto = findViewById(R.id.btn_auto);
mBtnDisconnect = findViewById(R.id.btn_disconnect);
}
@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(mWIFIStateReceiver);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_auto: {
if (mWIFIStateReceiver == null) {
mWIFIStateReceiver = new WIFIStateReceiver(MainActivity.this);
registerReceiver(mWIFIStateReceiver, new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION));
WIFIAutoConnectionService.start(this,mEtAccount.getText().toString().trim(),mEtPwd.getText().toString().trim());
}
}
break;
case R.id.btn_disconnect: {
WIFIConnectionManager.getInstance(this).disconnect();
WIFIConnectionManager.getInstance(this).closeWifi();
}
break;
}
}
}
服务类 WIFIStateReceiver
public class WIFIStateReceiver extends BroadcastReceiver {
private static final String TAG = WIFIStateReceiver.class.getName();
private Context mContext;
List<ScanResult> scanResults;
public WIFIStateReceiver(Context context) {
this.mContext = context;
}
@Override
public void onReceive(Context context, Intent intent) {
if (!intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
return;
}
scanResults = WIFIConnectionManager.getInstance(mContext).getWifiManager().getScanResults();
for (int i = 0 ; i < scanResults.size();i++) {
Log.e(TAG,"scanResults:----"+(scanResults.get(i)).SSID);
}
if (!WIFIConnectionManager.getInstance(mContext).isConnected("Wi-Fi名称")) {
WIFIConnectionManager.getInstance(mContext).connect("Wi-Fi名称", "Wi-Fi密码");
}
}
}
工具类 WIFIConnectionManager
public class WIFIConnectionManager {
private static final String TAG = WIFIConnectionManager.class.getName();
private static WIFIConnectionManager sInstance = null;
private android.net.wifi.WifiManager mWifiManager;
private int networkId;
public WIFIConnectionManager(Context context) {
mWifiManager = (android.net.wifi.WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
}
public static WIFIConnectionManager getInstance(Context context) {
if (sInstance == null) {
synchronized (WIFIConnectionManager.class) {
if (sInstance == null) {
sInstance = new WIFIConnectionManager(context);
}
}
}
return sInstance;
}
/**
* 尝试连接指定wifi
*
* @param ssid wifi名
* @param password 密码
* @return 是否连接成功
*/
public boolean connect(@NonNull String ssid, @NonNull String password) {
Log.d(TAG, "connect() called with: ssid = [" + ssid + "], password = [" + password + "]");
Log.d(TAG, "connect: wifi opened = " + openWifi());
boolean isConnected = isConnected(ssid);//当前已连接至指定wifi
Log.d(TAG, "connect: is already connected = " + isConnected);
if (isConnected) {
return true;
}
networkId = mWifiManager.addNetwork(newWifiConfig(ssid, password, true));
boolean result = mWifiManager.enableNetwork(networkId, true);
Log.d(TAG, "connect: network enabled = " + result);
return result;
}
/**
* 根据wifi名与密码配置 WiFiConfiguration, 每次尝试都会先断开已有连接
*
* @param isClient 当前设备是作为客户端,还是作为服务端, 影响SSID和PWD
*/
@NonNull
private WifiConfiguration newWifiConfig(String ssid, String password, boolean isClient) {
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
if (isClient) {//作为客户端, 连接服务端wifi热点时要加双引号
config.SSID = "\"" + ssid + "\"";
config.preSharedKey = "\"" + password + "\"";
} else {//作为服务端, 开放wifi热点时不需要加双引号
config.SSID = ssid;
config.preSharedKey = password;
}
config.hiddenSSID = true;
config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
return config;
}
/**
* @return 热点是否已开启
*/
public boolean isWifiEnabled() {
try {
Method methodIsWifiApEnabled = WifiManager.class.getDeclaredMethod("isWifiApEnabled");
return (boolean) methodIsWifiApEnabled.invoke(mWifiManager);
} catch (Exception e) {
Log.e(TAG, "isWifiEnabled: ", e);
return false;
}
}
/**
* 是否已连接指定wifi
*/
public boolean isConnected(String ssid) {
WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
if (wifiInfo == null) {
return false;
}
switch (wifiInfo.getSupplicantState()) {
case AUTHENTICATING:
case ASSOCIATING:
case ASSOCIATED:
case FOUR_WAY_HANDSHAKE:
case GROUP_HANDSHAKE:
case COMPLETED:
return wifiInfo.getSSID().replace("\"", "").equals(ssid);
default:
return false;
}
}
/**
* 打开WiFi
* @return
*/
public boolean openWifi() {
boolean opened = true;
if (!mWifiManager.isWifiEnabled()) {
opened = mWifiManager.setWifiEnabled(true);
}
return opened;
}
/**
* 关闭wifi
* @return
*/
public boolean closeWifi() {
boolean closed = true;
if (mWifiManager.isWifiEnabled()) {
closed = mWifiManager.setWifiEnabled(false);
}
return closed;
}
/**
* 断开连接
* @return
*/
public WIFIConnectionManager disconnect() {
if (networkId != 0) {
mWifiManager.disableNetwork(networkId);
}
mWifiManager.disconnect();
return this;
}
/**
* 是否连接过指定Wifi
*/
@Nullable
public WifiConfiguration everConnected(String ssid) {
List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
if (existingConfigs == null || existingConfigs.isEmpty()) {
return null;
}
ssid = "\"" + ssid + "\"";
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals(ssid)) {
return existingConfig;
}
}
return null;
}
/**
* 获取本机的ip地址
*/
@Nullable
public String getLocalIp() {
return convertIp(mWifiManager.getConnectionInfo().getIpAddress());
}
private String convertIp(int ipAddress) {
if (ipAddress == 0) return null;
return ((ipAddress & 0xff) + "." + (ipAddress >> 8 & 0xff) + "."
+ (ipAddress >> 16 & 0xff) + "." + (ipAddress >> 24 & 0xff));
}
public WifiManager getWifiManager() {
return mWifiManager;
}
}
WIFIAutoConnectionService
public class WIFIAutoConnectionService extends Service {
public static final String SSID = "HUAWEI";
public static final String PWD = "nihao321";
private static final String TAG = WIFIAutoConnectionService.class.getSimpleName();
private static final String KEY_SSID = "WI-FI名称";
private static final String KEY_PWD = "WI-FI密码";
/**
* wifi名
*/
private String mSsid = "";
/**
* 密码
*/
private String mPwd = "";
/**
* 负责不断尝试连接指定wifi
*/
private Handler mHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
WIFIConnectionManager.getInstance(WIFIAutoConnectionService.this).connect(mSsid, mPwd);
boolean connected = WIFIConnectionManager.getInstance(WIFIAutoConnectionService.this).isConnected(mSsid);
Log.d(TAG, "handleMessage: wifi connected = " + connected);
if (!connected) {
Log.d(TAG, "handleMessage: re-try in 5 seconds");
mHandler.sendEmptyMessageDelayed(0, 5000);//5s循环
}
return true;
}
});
/**
* 连接指定wifi热点, 失败后5s循环
*
* @param context 用于启动服务的上下文
* @param ssid 默认HUD-WIFI
* @param pwd (WPA加密)默认12345678
*/
public static void start(Context context, String ssid, String pwd) {
Intent starter = new Intent(context,WIFIAutoConnectionService.class);
starter.putExtra(KEY_SSID, ssid).putExtra(KEY_PWD, pwd);
context.startService(starter);
Log.d(TAG, "start: ");
}
@Override
public void onCreate() {
super.onCreate();
}
/**
* @return always null
*/
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
mSsid = intent.getStringExtra(KEY_SSID);
mPwd = intent.getStringExtra(KEY_PWD);
mHandler.sendEmptyMessage(0);
return START_NOT_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy: ");
}
}
这里只需要把Wi-Fi名称和密码换成自己所需要的就可以实现功能了。