现需求，当用户开机的时候要进行用户登录与注册。没联网要进行wifi连接，坑爹的是要求引导用户进行wifi连接，所以要做一个简单的wifi连接跳到登录页面的操作。
解决方案：
1.获取wifi列表，也就是扫描wifi，很简单，网上代码一大把。
/**
* 扫描wifi
*/
public void startScan() {
mWifiManager.startScan();
// 得到扫描结果
mWifiList = mWifiManager.getScanResults();
// 得到配置好的网络连接
mWifiConfigurations = mWifiManager.getConfiguredNetworks();
}2.连接wifi。连接wifi好像就是指给wifi添加配置信息，大概的意思是，当你手动连接wifi的时候，输入密码，就相当于给这个wifi添加配置信息的意思。
/**
* 添加指定WIFI的配置信息,原列表不存在此SSID
*
* @param wifiList
* @param ssid
* @param pwd
* @return
*/
public int AddWifiConfig(List<ScanResult> wifiList, String ssid, String pwd) {
int wifiId = -1;
for (int i = 0; i < wifiList.size(); i++) {
ScanResult wifi = wifiList.get(i);
if (wifi.SSID.equals(ssid)) {
Log.i("AddWifiConfig", "equals");
WifiConfiguration wifiCong = new WifiConfiguration();
wifiCong.SSID = "\"" + wifi.SSID + "\"";// \"转义字符，代表"
wifiCong.preSharedKey = "\"" + pwd + "\"";// WPA-PSK密码
wifiCong.hiddenSSID = false;
wifiCong.status = WifiConfiguration.Status.ENABLED;
wifiId = mWifiManager.addNetwork(wifiCong);// 将配置好的特定WIFI密码信息添加,添加完成后默认是不激活状态，成功返回ID，否则为-1
if (wifiId != -1) {
return wifiId;
}
}
}
return wifiId;
}3.如何判定当前的wifi连接成功，期初想法是获得当前要连的wifi的SSID，可能会拿到密码，与我的密码做比较，但转念一想，wifi的真实密码，是不可能外部透露的。看到百度上别人写的：配置完wifi的信息，再获取一遍WifiInfo,拿到wifiinfo里的ssid与当前我要连接的wifi的ssid比较，如果一致就是连接正确，但亲测有问题。于是我就想这么来:
RxView.clicks(btn_conn).throttleFirst(1, TimeUnit.SECONDS).subscribe(new Action1<Void>() {
@Override
public void call(Void aVoid) {
pwd=et_pwd.getText().toString();
//Toast.makeText(WifiActivity.this,currentSSID,Toast.LENGTH_SHORT).show();
if (pwd!=null&& !TextUtils.isEmpty(pwd)&¤tSSID!=null&&!TextUtils.isEmpty(currentSSID)){
ProjectUtils.showDialog(WifiActivity.this);
int wifiItemId = wiFiUtils.IsConfiguration("\""
+ currentSSID + "\"");
/* if (wifiItemId != -1) {
if (wiFiUtils.ConnectWifi(wifiItemId)) {
// 连接已保存密码的WiFi
ProjectUtils.dismissDialog();
Toast.makeText(getApplicationContext(), "正在连接",
Toast.LENGTH_SHORT).show();
}
}else{*/
//链接wifi
int netId = wiFiUtils
.AddWifiConfig(wifiList,
currentSSID,
pwd);
if (netId!=-1){
wiFiUtils.getConfiguration();// 添加了配置信息，要重新得到配置信息
wiFiUtils.ConnectWifi(netId);
final int countTime = 0;
RxUtils.unsubscribe(subscription);
subscription = Observable.interval(0, 1, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return new SimpleDateFormat("ss").format((countTime + aLong.intValue()) * 1000);
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
WifiInfo wifiInfo = wiFiUtils.getmWifiManager().getConnectionInfo();
// wifiInfo.getState().equals(NetworkInfo.State.CONNECTED)
Log.i("Wifi扫描ING::",s+"/"+wifiInfo.getSSID());
if (s.equals("05")) {
if (ProjectUtils.isNetworkAvailable(WifiActivity.this)){
ProjectUtils.dismissDialog();
// if (wifiInfo.getSSID().contains(currentSSID)) {
RxUtils.unsubscribe(subscription);
Toast.makeText(WifiActivity.this,"Wifi连接成功",Toast.LENGTH_SHORT).show();
startActivity(new Intent(WifiActivity.this,UserLoginActivity.class));
Log.i("Wifi扫描结果::", "Success");
// }
}
} else if (s.equals("10")) {
ProjectUtils.dismissDialog();
if (!ProjectUtils.isNetworkAvailable(WifiActivity.this)){
RxUtils.unsubscribe(subscription);
Log.i("Wifi扫描结果::", "ERROR");
Toast.makeText(WifiActivity.this,"密码不正确",Toast.LENGTH_SHORT).show();
et_pwd.setText("");
}else{
ProjectUtils.dismissDialog();
RxUtils.unsubscribe(subscription);
Toast.makeText(WifiActivity.this,"Wifi连接成功",Toast.LENGTH_SHORT).show();
startActivity(new Intent(WifiActivity.this,UserLoginActivity.class));
Log.i("Wifi扫描结果::", "Success");
}
}
}
});
// RxUtils.countUpTime()
/* Toast.makeText(WifiActivity.this,"连接"+currentSSID+"成功",Toast.LENGTH_SHORT).show();
if () {
// 连接成功，刷新UI
ProjectUtils.dismissDialog();
}
*/
}else {
ProjectUtils.dismissDialog();
Toast.makeText(WifiActivity.this,"密码必须是八位",Toast.LENGTH_SHORT).show();
et_pwd.setText("");
}
// }
}else{
if (TextUtils.isEmpty(pwd)){
Toast.makeText(WifiActivity.this,"请输入wifi密码",Toast.LENGTH_SHORT).show();
}
}
}
});大概的意思是,配置完wifi信息的时候，我起一个线程计时，如果10s内有网就说明wifi连接成功了，没有就密码错了，因为现在基本都是rxjava那一套，线程也相当好控制。不知道大家有没有更加好的方法。
附件:
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Color;
import android.graphics.Typeface;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiInfo;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast;
import com.jakewharton.rxbinding.view.RxView;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import customview.myspinner.NiceSpinner;
import rx.Observable;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action1;
import rx.functions.Func1;
import utils.ActivityUtils;
import utils.ProjectUtils;
import utils.RxUtils;
import utils.WiFiUtils;
public class WifiActivity extends BaseActivity {
private WiFiUtils wiFiUtils;
private List<ScanResult> wifiList;
private NiceSpinner sp_wifi;
private Typeface mtypeface;
private String currentSSID;
private EditText et_pwd;
private Button btn_conn;
private String pwd;
private ImageView iv_back,iv_battery, iv_tf,iv_wifi;
private RelativeLayout rl_bg;
Subscription subscription;
private ActivityUtils activityUtils;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_wifi);
activityUtils=ActivityUtils.getIntance();
activityUtils.putActivity("WifiActivity",WifiActivity.this);
initUI();
batteryState(iv_battery);
tFCardListener(iv_tf);
wifiListener(iv_wifi, WifiActivity.this);
initData();
/*IntentFilter filter=new IntentFilter();
filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
registerReceiver(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) {
int linkWifiResult = intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, 123);
Log.i("MYWIFI::","wifi密码错误广播"+linkWifiResult);
if (linkWifiResult == WifiManager.ERROR_AUTHENTICATING) {
Toast.makeText(WifiActivity.this,"连接"+currentSSID+"失败，请核对密码",Toast.LENGTH_SHORT).show();
}
}
}
},filter);*/
}
@Override
protected void onResume() {
super.onResume();
/**
* 放送禁止菜单键的广播
*/
Intent intent=new Intent();
intent.setAction("menu_disable");
sendBroadcast(intent);
}
private void initUI() {
rl_bg= (RelativeLayout) findViewById(R.id.rl_bg);
iv_back= (ImageView) findViewById(R.id.iv_back);
iv_back.setVisibility(View.GONE);
iv_battery = (ImageView) findViewById(R.id.iv_battery);
iv_wifi = (ImageView) findViewById(R.id.iv_wifi);
// RxView.clicks(iv_wifi).throttleFirst(1,TimeUnit.SECONDS).subscribe(new Action1<Void>() {
// @Override
// public void call(Void aVoid) {
// startActivity(new
// Intent(Settings.ACTION_WIFI_SETTINGS));
// }
// });
iv_tf = (ImageView) findViewById(R.id.iv_tf);
sp_wifi= (NiceSpinner) findViewById(R.id.sp_wifi);
et_pwd= (EditText) findViewById(R.id.et_pwd);
btn_conn= (Button) findViewById(R.id.btn_conn);
}
private void exchangeZhuti(RelativeLayout ll_root) {
SharedPreferences sp = getSharedPreferences("setting", Context.MODE_PRIVATE);
String theme = sp.getString("theme", "bgone");
if (ll_root != null) {
switch (theme) {
case "bgone":
ll_root.setBackgroundResource(R.mipmap.bgone);
break;
case "bgtwo":
ll_root.setBackgroundResource(R.mipmap.bgtwo);
break;
case "bgthree":
ll_root.setBackgroundResource(R.mipmap.bgthree);
break;
}
}
}
void getWifi(){
/**
* 扫描
*/
wiFiUtils.startScan();
List<String> list=new ArrayList<String>();
wifiList = wiFiUtils.getWifiList();
wiFiUtils.getConfiguration();
if (wifiList!=null){
for (int i = 0; i < wifiList.size(); i++) {
//Log.i("Wifi扫描结果::",wifiList.get(i).toString());
list.add(wifiList.get(i).SSID);
}
if (wifiList.size()!=0){
currentSSID=wifiList.get(0).SSID;
}
if (list!=null&&list.size()!=0){
sp_wifi.attachDataSource(list);
}
}
}
private void initData() {
/**
* 加载主题背景
*/
exchangeZhuti(rl_bg);
mtypeface = Typeface.createFromAsset(getAssets(), "ziti1.ttf");
wiFiUtils=new WiFiUtils(WifiActivity.this);
getWifi();
sp_wifi.setTextColor(Color.parseColor("#333333"));
sp_wifi.setTypeface(mtypeface);
sp_wifi.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
if (wifiList!=null&&position<wifiList.size()){
currentSSID=wifiList.get(position).SSID;
}
Log.i("HHH::","onItemSelected");
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
Log.i("HHH::","onNothingSelected");
}
});
sp_wifi.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.i("HHH::","onClick");
getWifi();
}
});
RxView.clicks(btn_conn).throttleFirst(1, TimeUnit.SECONDS).subscribe(new Action1<Void>() {
@Override
public void call(Void aVoid) {
pwd=et_pwd.getText().toString();
//Toast.makeText(WifiActivity.this,currentSSID,Toast.LENGTH_SHORT).show();
if (pwd!=null&& !TextUtils.isEmpty(pwd)&¤tSSID!=null&&!TextUtils.isEmpty(currentSSID)){
ProjectUtils.showDialog(WifiActivity.this);
int wifiItemId = wiFiUtils.IsConfiguration("\""
+ currentSSID + "\"");
/* if (wifiItemId != -1) {
if (wiFiUtils.ConnectWifi(wifiItemId)) {
// 连接已保存密码的WiFi
ProjectUtils.dismissDialog();
Toast.makeText(getApplicationContext(), "正在连接",
Toast.LENGTH_SHORT).show();
}
}else{*/
//链接wifi
int netId = wiFiUtils
.AddWifiConfig(wifiList,
currentSSID,
pwd);
if (netId!=-1){
wiFiUtils.getConfiguration();// 添加了配置信息，要重新得到配置信息
wiFiUtils.ConnectWifi(netId);
final int countTime = 0;
RxUtils.unsubscribe(subscription);
subscription = Observable.interval(0, 1, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return new SimpleDateFormat("ss").format((countTime + aLong.intValue()) * 1000);
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
WifiInfo wifiInfo = wiFiUtils.getmWifiManager().getConnectionInfo();
// wifiInfo.getState().equals(NetworkInfo.State.CONNECTED)
Log.i("Wifi扫描ING::",s+"/"+wifiInfo.getSSID());
if (s.equals("05")) {
if (ProjectUtils.isNetworkAvailable(WifiActivity.this)){
ProjectUtils.dismissDialog();
// if (wifiInfo.getSSID().contains(currentSSID)) {
RxUtils.unsubscribe(subscription);
Toast.makeText(WifiActivity.this,"Wifi连接成功",Toast.LENGTH_SHORT).show();
startActivity(new Intent(WifiActivity.this,UserLoginActivity.class));
Log.i("Wifi扫描结果::", "Success");
// }
}
} else if (s.equals("10")) {
ProjectUtils.dismissDialog();
if (!ProjectUtils.isNetworkAvailable(WifiActivity.this)){
RxUtils.unsubscribe(subscription);
Log.i("Wifi扫描结果::", "ERROR");
Toast.makeText(WifiActivity.this,"密码不正确",Toast.LENGTH_SHORT).show();
et_pwd.setText("");
}else{
ProjectUtils.dismissDialog();
RxUtils.unsubscribe(subscription);
Toast.makeText(WifiActivity.this,"Wifi连接成功",Toast.LENGTH_SHORT).show();
startActivity(new Intent(WifiActivity.this,UserLoginActivity.class));
Log.i("Wifi扫描结果::", "Success");
}
}
}
});
// RxUtils.countUpTime()
/* Toast.makeText(WifiActivity.this,"连接"+currentSSID+"成功",Toast.LENGTH_SHORT).show();
if () {
// 连接成功，刷新UI
ProjectUtils.dismissDialog();
}
*/
}else {
ProjectUtils.dismissDialog();
Toast.makeText(WifiActivity.this,"密码必须是八位",Toast.LENGTH_SHORT).show();
et_pwd.setText("");
}
// }
}else{
if (TextUtils.isEmpty(pwd)){
Toast.makeText(WifiActivity.this,"请输入wifi密码",Toast.LENGTH_SHORT).show();
}
}
}
});
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK)) {
return true;
}else {
return super.onKeyDown(keyCode, event);
}
}
}
package utils;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.util.Log;
import java.util.List;
/**
* Created by hcy on 2017/8/18 0018.
*/
public class WiFiUtils {
/**
* 定义一个WifiManager对象,提供Wifi管理的各种主要API，主要包含wifi的扫描、建立连接、配置信息等
*/
private WifiManager mWifiManager;
// WIFIConfiguration描述WIFI的链接信息，包括SSID、SSID隐藏、password等的设置
private List<WifiConfiguration> wifiConfigList;
// 定义一个WifiInfo对象
private WifiInfo mWifiInfo;
// 扫描出的网络连接列表
private List<ScanResult> mWifiList;
// 网络连接列表
private List<WifiConfiguration> mWifiConfigurations;
private WifiManager.WifiLock mWifiLock;
public static final int TYPE_NO_PASSWD = 0x11;
public static final int TYPE_WEP = 0x12;
public static final int TYPE_WPA = 0x13;
public WifiManager getmWifiManager() {
return mWifiManager;
}
public WiFiUtils(Context context) {
// 获得WifiManager对象
mWifiManager = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
/**
* 如果wifi没有打开，默认打开wifi
*/
if (!mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(true);
}
mWifiInfo = mWifiManager.getConnectionInfo();
}
/**
* 打开wifi
*/
public void openWifi() {
if (!mWifiManager.isWifiEnabled()) {
mWifiManager.setWifiEnabled(true);
}
}
/**
* 关闭wifi
*/
public void closeWifi() {
if (!mWifiManager.isWifiEnabled()) {
mWifiManager.setWifiEnabled(false);
}
}
/**
* 检查当前wifi状态
*
* @return
*/
public int checkState() {
return mWifiManager.getWifiState();
}
/**
* 锁定wifiLock
*/
public void acquireWifiLock() {
mWifiLock.acquire();
}
/**
* 解锁wifiLock
*/
public void releaseWifiLock() {
// 判断是否锁定
if (mWifiLock.isHeld()) {
mWifiLock.acquire();
}
}
/**
* 创建一个wifiLock
*/
public void createWifiLock() {
mWifiLock = mWifiManager.createWifiLock("test");
}
/**
* 得到配置好的网络
*
* @return
*/
public List<WifiConfiguration> getWiFiConfiguration() {
return mWifiConfigurations;
}
/**
* 指定配置好的网络进行连接
*
* @param index
*/
public void connetionConfiguration(int index) {
if (index > mWifiConfigurations.size()) {
return;
}
// 连接配置好指定ID的网络
mWifiManager.enableNetwork(mWifiConfigurations.get(index).networkId,
true);
}
/**
* 扫描wifi
*/
public void startScan() {
mWifiManager.startScan();
// 得到扫描结果
mWifiList = mWifiManager.getScanResults();
// 得到配置好的网络连接
mWifiConfigurations = mWifiManager.getConfiguredNetworks();
}
/**
* 得到网络列表
*
* @return wifi扫描结果
*/
public List<ScanResult> getWifiList() {
return mWifiList;
}
/**
* 查看扫描结果
*
* @return
*/
public StringBuffer lookUpScan() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < mWifiList.size(); i++) {
sb.append("Index_" + new Integer(i + 1).toString() + ":");
// 将ScanResult信息转换成一个字符串包
// 其中把包括：BSSID、SSID、capabilities、frequency、level
sb.append((mWifiList.get(i)).toString()).append("\n");
}
return sb;
}
public String getMacAddress() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
}
public String getBSSID() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
}
public int getIpAddress() {
return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
}
/**
* 得到连接的ID
*
* @return
*/
public int getNetWordId() {
return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
}
/**
* 得到wifiInfo的所有信息
*
* @return
*/
public String getWifiInfo() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
}
/**
* 添加一个网络并连接
*
* @param configuration
*/
public void addNetwork(WifiConfiguration configuration) {
int wcgId = mWifiManager.addNetwork(configuration);
mWifiManager.enableNetwork(wcgId, true);
}
/**
* 连接某个wifi
*/
public WifiConfiguration createWifiInfo(String SSID, String Password,
int Type) {
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";
WifiConfiguration tempConfig = this.isExsits(SSID);
if (tempConfig != null) {
mWifiManager.removeNetwork(tempConfig.networkId);
}
if (Type == 1) // WIFICIPHER_NOPASS
{
config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (Type == 2) // WIFICIPHER_WEP
{
config.hiddenSSID = true;
config.wepKeys[0] = "\"" + Password + "\"";
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.SHARED);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
config.allowedGroupCiphers
.set(WifiConfiguration.GroupCipher.WEP104);
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (Type == 3) // WIFICIPHER_WPA
{
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.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
return config;
}
/**
* 判断某个wifi是否存在
*/
private WifiConfiguration isExsits(String ssid) {
WifiConfiguration config = new WifiConfiguration();
if (mWifiList.size() > 0) {
for (int i = 0; i < mWifiList.size(); i++) {
if (mWifiList.get(i).SSID.equals(ssid)) {
config = mWifiConfigurations.get(i);
}
}
}
return config;
}
/**
* 断开指定ID的网络
*
* @param netId
*/
public void disConnectionWifi(int netId) {
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}
// ============
/**
* 连接指定Id的WIFI
*
* @param wifiId
* @return
*/
public boolean ConnectWifi(int wifiId) {
for (int i = 0; i < wifiConfigList.size(); i++) {
WifiConfiguration wifi = wifiConfigList.get(i);
if (wifi.networkId == wifiId) {
while (!(mWifiManager.enableNetwork(wifiId, true))) {// 激活该Id，建立连接
Log.i("ConnectWifi",
String.valueOf(wifiConfigList.get(wifiId).status));// status:0--已经连接，1--不可连接，2--可以连接
}
return true;
}
}
return false;
}
/**
* 得到Wifi配置好的信息
*/
public void getConfiguration() {
wifiConfigList = mWifiManager.getConfiguredNetworks();// 得到配置好的网络信息
for (int i = 0; i < wifiConfigList.size(); i++) {
Log.i("getConfiguration", wifiConfigList.get(i).SSID);
Log.i("getConfiguration",
String.valueOf(wifiConfigList.get(i).networkId));
}
}
/**
* 判定指定WIFI是否已经配置好,依据WIFI的地址BSSID,返回NetId
*
* @param SSID
* @return
*/
public int IsConfiguration(String SSID) {
Log.i("IsConfiguration", String.valueOf(wifiConfigList.size()));
for (int i = 0; i < wifiConfigList.size(); i++) {
Log.i(wifiConfigList.get(i).SSID,
String.valueOf(wifiConfigList.get(i).networkId));
if (wifiConfigList.get(i).SSID.equals(SSID)) {// 地址相同
return wifiConfigList.get(i).networkId;
}
}
return -1;
}
/**
* 添加指定WIFI的配置信息,原列表不存在此SSID
*
* @param wifiList
* @param ssid
* @param pwd
* @return
*/
public int AddWifiConfig(List<ScanResult> wifiList, String ssid, String pwd) {
int wifiId = -1;
for (int i = 0; i < wifiList.size(); i++) {
ScanResult wifi = wifiList.get(i);
if (wifi.SSID.equals(ssid)) {
Log.i("AddWifiConfig", "equals");
WifiConfiguration wifiCong = new WifiConfiguration();
wifiCong.SSID = "\"" + wifi.SSID + "\"";// \"转义字符，代表"
wifiCong.preSharedKey = "\"" + pwd + "\"";// WPA-PSK密码
wifiCong.hiddenSSID = false;
wifiCong.status = WifiConfiguration.Status.ENABLED;
wifiId = mWifiManager.addNetwork(wifiCong);// 将配置好的特定WIFI密码信息添加,添加完成后默认是不激活状态，成功返回ID，否则为-1
if (wifiId != -1) {
return wifiId;
}
}
}
return wifiId;
}
}
package utils;
import com.orhanobut.logger.Logger;
import java.text.SimpleDateFormat;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;
import rx.Observable;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
/**
* Created by hcy on 2017/2/24.
*/
public class RxUtils {
//倒计时
public static Observable<String> countDownTime(int time) {
if (time < 0) {
time = 0;
}
final int countTime = time;
return Observable.interval(0,1, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
//解决八小时的时区问题
String format = new SimpleDateFormat("ss").format((countTime - aLong.intValue()) * 1000- TimeZone.getDefault().getRawOffset());
Logger.i("倒计时：："+format);
return format;
}
})
.take(countTime + 1);
}
//正计时
public static Observable<String> countUpTime() {
final int countTime = 0;
return Observable.interval(0,1, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return new SimpleDateFormat("HH:mm:ss").format((countTime + aLong.intValue())*1000);
}
});
}
public static void unsubscribe(Subscription subscription) {
if (subscription != null && !subscription.isUnsubscribed()) {
subscription.unsubscribe();
}
}
}
2164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
