Android系统应用开发（三）WIFI信号及电池电量检测

//wifi管理类
public class WifiAdmin {
// 定义WifiManager对象
public WifiManager mWifiManager;
// 定义WifiInfo对象
private WifiInfo mWifiInfo;
// 扫描出的网络连接列表
private List<ScanResult> mWifiList;
// 网络连接列表
private List<WifiConfiguration> mWifiConfiguration;
// 定义一个WifiLock
WifiLock mWifiLock;

// 构造器
public WifiAdmin(Context context) {
// 取得WifiManager对象
mWifiManager = (WifiManager) context
.getSystemService(Context.WIFI_SERVICE);
// 取得WifiInfo对象
mWifiInfo = mWifiManager.getConnectionInfo();
}

// 打开WIFI
public void openWifi() {
if (!mWifiManager.isWifiEnabled()) {
mWifiManager.setWifiEnabled(true);
}
}

// 关闭WIFI
public void closeWifi() {
if (mWifiManager.isWifiEnabled()) {
mWifiManager.setWifiEnabled(false);
}
}

// 检查当前WIFI状态
public int checkState() {
return mWifiManager.getWifiState();
}

// 锁定WifiLock
public void acquireWifiLock() {
mWifiLock.acquire();
}

// 解锁WifiLock
public void releaseWifiLock() {
// 判断时候锁定
if (mWifiLock.isHeld()) {
mWifiLock.acquire();
}
}

// 创建一个WifiLock
public void creatWifiLock() {
mWifiLock = mWifiManager.createWifiLock("Test");
}

// 得到配置好的网络
public List<WifiConfiguration> getConfiguration() {
return mWifiConfiguration;
}

// 指定配置好的网络进行连接
public void connectConfiguration(int index) {
// 索引大于配置好的网络索引返回
if (index > mWifiConfiguration.size()) {
return;
}
// 连接配置好的指定ID的网络
mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
true);
}

public void startScan() {
mWifiManager.startScan();
// 得到扫描结果
mWifiList = mWifiManager.getScanResults();
// 得到配置好的网络连接
mWifiConfiguration = mWifiManager.getConfiguredNetworks();
}

// 得到网络列表
public List<ScanResult> getWifiList() {
return mWifiList;
}

// 查看扫描结果
public StringBuilder lookUpScan() {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < mWifiList.size(); i++) {
stringBuilder
.append("Index_" + new Integer(i + 1).toString() + ":");
// 将ScanResult信息转换成一个字符串包
// 其中把包括：BSSID、SSID、capabilities、frequency、level
stringBuilder.append((mWifiList.get(i)).toString());
stringBuilder.append("/n");
}
return stringBuilder;
}

// 得到MAC地址
public String getMacAddress() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
}

// 得到接入点的BSSID
public String getBSSID() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
}

// 得到IP地址
public int getIPAddress() {
return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
}

// 得到连接的ID
public int getNetworkId() {
return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
}

// 得到WifiInfo的所有信息包
public String getWifiInfo() {
return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
}

// 添加一个网络并连接
public void addNetwork(WifiConfiguration wcg) {
int wcgID = mWifiManager.addNetwork(wcg);
boolean b =  mWifiManager.enableNetwork(wcgID, true);
System.out.println("a--" + wcgID);
System.out.println("b--" + b);
}

// 断开指定ID的网络
public void disconnectWifi(int netId) {
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}

//然后是一个实际应用方法，只验证过没有密码的情况：

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)
{
List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs)
{
if (existingConfig.SSID.equals("/"+SSID+"/"))
{
return existingConfig;
}
}
return null;
}

}

private WifiAdmin mwAdmin;//wifi管理
private int level ;//wifi信号量

/**
*@exception :启动定时器一秒检测一次信号量
* **/
private void startTimer(){

mTimer.schedule(new TimerTask() {

@Override
public void run() {
// TODO Auto-generated method stub
//获得信号强度值
level = mwAdmin.mWifiManager.getConnectionInfo().getRssi();
Message message = Message.obtain();
//根据获得的信号强度发送信息
if (level <= 0 && level >= -50) {
message.what = 1;
} else if (level < -50 && level >= -70) {

message.what = 2;
} else if (level < -70 && level >= -80) {

message.what = 3;
} else if (level < -80 && level >= -100) {

message.what = 4;
} else {

message.what = 5;
}
mHandler.sendMessage(message);
}
}, 0, 1000);
}

/*  根据msg换图标*/
Timer mTimer = new Timer();
/* */
public static  Handler mHandler = new Handler(){

public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
TV_wifi.setBackgroundResource(R.drawable.wifi4);
break;
case 2:
TV_wifi.setBackgroundResource(R.drawable.wifi3);
break;
case 3:
TV_wifi.setBackgroundResource(R.drawable.wifi2);
break;
case 4:
TV_wifi.setBackgroundResource(R.drawable.wifi1);
break;
case 5:
TV_wifi.setBackgroundResource(R.drawable.wifi0);
break;
default:
break;
}
};
};

public class AllBroadcastReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {
int networkTtpe= 0;
NetworkInfo netInfo;
String action = intent.getAction();
if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {

LogUtils.i("level", "level  " + intent.getIntExtra("level", 0));
//电池电量
int level = intent.getIntExtra("level", 0);
//电池状态
int status=intent.getIntExtra("status",BatteryManager.BATTERY_STATUS_UNKNOWN);
if (status==BatteryManager.BATTERY_STATUS_CHARGING) {
networkTtpe = 9;

}else if (100 >= level && level >80) {
networkTtpe = 4;
}else if (80 >= level && level > 50) {
networkTtpe = 5;
}else if (50 >= level && level > 30) {
networkTtpe = 6;
}else if (30 >= level && level > 10) {
networkTtpe = 7;
}else if (10 >= level && level >= 0) {
networkTtpe = 8;
}
LogUtils.i("setNetworkTtpe", "setNetworkTtpe  " +networkTtpe);

}
}
}

/**
*注册广播
***/
private void initReceiver() {

IntentFilter mFilter = new IntentFilter();
mFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
mFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
mFilter.addAction(Intent.ACTION_BATTERY_LOW);
registerReceiver(mNetworkBroadcastReceiver, mFilter);
}

权限
<uses-permission android:name="android.permission.BATTERY_STATS"></uses-permission>