这段时间一直在完成项目的wifi功能，是有一个界面去展示wifi列表，并且根据扫描出来的列表项更新每个子item的状态，包括连接中、已连接、已保存等等这些状态。一开始看了网上很多demo，感谢前人给的一些开发经验。但是完整的跟ui交互这一块儿，貌似都没发现特别齐全的。我在gitub上面也有寻找，但是可惜的是并没有。所以走了很多弯路是正常的，但是没关系，总算柳暗花明又一村了。现在特意花时间将自己的成果展示出来，同时也希望在写wifi的小伙伴们能够少走一点弯路。
废话不多说，现在就开始进入正题吧。
先上一下图吧：
大家都知道wifi的操作离不开一个类，那就是WiFiManager类，这个类里面的api提供了很多方法供开发者使用，忍不住点个赞。 上代码：
1.先看看我的WifiUtil类
public class WiFiUtil {
private static final String TAG = "WiFiUtil";
private WiFiUtil() {
throw new RuntimeException("this class can not be initialized");
}
public static WifiManager wifiManager(Context context){
return (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
}
/**
* 连接 wifi
* @param context
* @param name wifi名称
* @return
*/
public static boolean connectWiFi(Context context,String name,String password){
WifiManager wifiManager = wifiManager(context);
if (!wifiManager.isWifiEnabled()) {
wifiManager.setWifiEnabled(true);
}
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
if (wifiInfo != null && wifiInfo.getSSID() != null){
String ssid = wifiInfo.getSSID();
ssid = ssid.replace("\"", "");
if (ssid.equals(name)){
return true;
}
}
final WifiConfiguration wifiConfig = obtainWifiConfig(wifiManager,name,password);
if (wifiConfig == null) {
return false;
}
wifiManager.disconnect();
int netWorkId = wifiConfig.networkId;
if (netWorkId == -1) {
netWorkId = wifiManager.addNetwork(wifiConfig);
if (netWorkId != -1) {
Method connectMethod = connectWifi(wifiManager,netWorkId);
if (connectMethod == null) {
return wifiManager.enableNetwork(wifiConfig.networkId, true);
}
}
} else {
Method connectMethod = connectWifi(wifiManager,netWorkId);
if (connectMethod == null) {
return wifiManager.enableNetwork(wifiConfig.networkId, true);
}
}
return true;
}
public static final int ESS = 0;
public static final int WEP = 1;
public static final int WPA = 2;
private static WifiConfiguration obtainWifiConfig(WifiManager wifiManager,String SSID, String password) {
int type = WPA;
WifiConfiguration wifiConfig = getSaveWifConfiguration(wifiManager,SSID);
if (wifiConfig == null){
wifiConfig = new WifiConfiguration();
}else {
return wifiConfig;
}
wifiConfig.SSID = "\"" + SSID + "\"";
switch (type) {
case ESS:
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
return wifiConfig;
case WEP:
wifiConfig.wepKeys[0] = "\"" + password + "\"";
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
wifiConfig.status = WifiConfiguration.Status.ENABLED;
return wifiConfig;
case WPA:
wifiConfig.preSharedKey = "\"" + password + "\"";
wifiConfig.status = WifiConfiguration.Status.ENABLED;
return wifiConfig;
default:
return null;
}
}
public static Method connectWifi(WifiManager wifiManager, int netId) {
System.out.println("========netId="+netId);
Method connectMethod = null;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
for (Method method : wifiManager.getClass().getDeclaredMethods()) {
if ("connect".equalsIgnoreCase(method.getName())) {
Class<?>[] types = method.getParameterTypes();
if (types != null && types.length > 0) {
if ("int".equalsIgnoreCase(types[0].getName())) {
connectMethod = method;
}
}
}
}
if (connectMethod != null) {
try {
connectMethod.invoke(wifiManager, netId, null);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
} else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.JELLY_BEAN) {
// 反射方法: connect(Channel c, int networkId, ActionListener listener)
// 暂时不处理4.1的情况 , 4.1 == phone's android version
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH
&& Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
// 反射方法：connectNetwork(int networkId) ,
// 4.0 <= phone's android version < 4.1
for (Method methodSub : wifiManager.getClass()
.getDeclaredMethods()) {
if ("connectNetwork".equalsIgnoreCase(methodSub.getName())) {
Class<?>[] types = methodSub.getParameterTypes();
if (types != null && types.length > 0) {
if ("int".equalsIgnoreCase(types[0].getName())) {
connectMethod = methodSub;
}
}
}
}
if (connectMethod != null) {
try {
connectMethod.invoke(wifiManager, netId);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
} else {
return null;
}
return connectMethod;
}
public static WifiConfiguration getSaveWifConfiguration(WifiManager wifiManager,String name) {
WifiConfiguration wifiConfiguration = null;
List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
if (configuredNetworks != null) {
for (WifiConfiguration configuration : configuredNetworks) {
if (configuration.SSID.replace("\"", "").equals(name.replace("\"", ""))) {
wifiConfiguration = configuration;
break;
}
}
}
return wifiConfiguration;
}
/**
* 忘记网络
* @param context
* @param name
*/
public static void removeNetwork(Context context,String name){
WifiManager wifiManager = wifiManager(context);
if (!wifiManager.isWifiEnabled()) {
wifiManager.setWifiEnabled(true);
}
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
if (wifiInfo != null && wifiInfo.getSSID() != null) {
String ssid = wifiInfo.getSSID();
if (ssid.equals(name)) {
wifiManager.disconnect();
}
}
WifiConfiguration configuredNetworks = getSaveWifConfiguration(wifiManager, name);
if (configuredNetworks != null) {
wifiManager.removeNetwork(wifiManager.addNetwork(configuredNetworks));
}
/**
* 扫描wifi
*/
public static List<WifiItem> scanWifi(Context context){
WifiManager wifiManager = wifiManager(context);
wifiManager.startScan();
List<WifiItem> results = new ArrayList<>();
WifiInfo info = wifiManager.getConnectionInfo();
List<ScanResult> scanResults = wifiManager.getScanResults();
List<ScanResult> list = manageScanResult(scanResults);
List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
try{
w:for (ScanResult scan : list){
if (TextUtils.equals(scan.BSSID,info.getBSSID()) && !scan.SSID.equals("") ){
results.add(0,WifiItem.obtain(scan,WifiItem.CONNECTED));
Log.e(TAG, "添加已连接的到第一项成功");
continue ;
}
for (WifiConfiguration con:configuredNetworks){
if (TextUtils.equals(WifiItem.ssid(con.SSID) , scan.SSID)){
if (results.size() > 0)
results.add(1,WifiItem.obtain(scan,WifiItem.SAVED));
else
results.add(0,WifiItem.obtain(scan,WifiItem.SAVED));
continue w;
}
}
if (!TextUtils.equals("", scan.SSID))
results.add(WifiItem.obtain(scan,WifiItem.SCAN));
}
}catch (Exception e) {
e.printStackTrace();
}
return results;
}
/**
* 处理扫描出来的wifi，包括去除同名的，按照wifi信号强弱排序
*/
private static List<ScanResult> manageScanResult(List<ScanResult> list){
//去除同名
for ( int i = 0 ; i < list.size() - 1 ; i ++ ) {
for ( int j = list.size() - 1 ; j > i; j -- ) {
ScanResult scanResultTmpI = list.get(i);
ScanResult scanResultTmpJ = list.get(j);
if (scanResultTmpJ.SSID.equals(scanResultTmpI.SSID)) {
list.remove(j);
}
}
}
//按照信号强弱排序
if(list.size()>0) {
ScanResult scanResultTmpPre = null;
ScanResult scanResultTmpNex = null;
for (int i = 0; i < list.size() - 1; i++) {
for (int j = 0; j < list.size() - i - 1; j++) {
scanResultTmpPre = list.get(j);
scanResultTmpNex = list.get(j + 1);
//升序，信号是负值
if (Math.abs(scanResultTmpPre.level) > Math.abs(scanResultTmpNex.level)) {
list.set(j, scanResultTmpNex);
list.set(j + 1, scanResultTmpPre);
}
}
}
}
return list;
}
/**
* 添加一个网络并连接
*/
public static boolean addNetwork(Context context, WifiConfiguration wcg) {
WifiManager manager = wifiManager(context);
int wcgID = manager.addNetwork(wcg);
boolean b = manager.enableNetwork(wcgID, true);
Log.e(TAG, "a--" + wcgID);
Log.e(TAG, "b--" + b);
return b;
}
// 查看以前是否也配置过这个网络
private static WifiConfiguration isExsits(WifiManager wifiManager, String SSID) {
List<WifiConfiguration> existingConfigs = wifiManager
.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
return existingConfig;
}
}
return null;
}
public static WifiConfiguration createWifiInfo(Context context, String SSID, String Password, int Type) {
WifiManager manager = wifiManager(context);
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";
WifiConfiguration tempConfig = isExsits(manager, SSID);
if (tempConfig != null){
manager.removeNetwork(tempConfig.networkId);
}
if (Type == 1) {//WIFICIPHER_NOPASS
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
}
if (Type == 2) {//WIFICIPHER_WEP
config.wepKeys[0] = Password;
config.hiddenSSID = true;
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.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
config.status = WifiConfiguration.Status.ENABLED;
}
return config;
}
}
注释已经很清楚了，然后需要注意的就是因为扫描出来的可能会存在有相同的ssid的情况，所以需要对扫描的结果进行清理，然后我这边是按照信号强弱有进行排序。当然，扫描的时候会有WifiItem，这个就是model数据模型了，因为涉及到要去更新每一项可能变化的状态，所以需要给它封装一下。以下是WiFiItem类：
2.WiFiItem类：
public class WiFiItem implements Serializable{
public static final String WIFI_AUTH_OPEN = “”;
public static final String WIFI_AUTH_ROAM = “[ESS]”;
/**
* 当前已连接
*/
public static final int CONNECT = 0x250;
/**
* 已保存
*/
public static final int SAVED = 0x251;
/**
* wifi在附近，扫描出来的，可连接
*/
public static final int SCAN = 0x252;
/**
* 正在连接
*/
public static final int CONNECTING = 0x253;
/**
* wifi名称
*/
private String ssid;
/**
* wifi路由器的 mac 地址
*/
private String bssid;
/**
* 信号等级
*/
private int level;
/**
* 该wifi状态
*/
private int state;
/**
* 安全性
*/
private String capabilities;
private int encrypt;
/**
* wifi info
*/
private Object data;
public WiFiItem() {
}
public String getSsid() {
return ssid;
}
public void setSsid(String ssid) {
this.ssid = ssid;
}
public String getBssid() {
return bssid;
}
public void setBssid(String bssid) {
this.bssid = bssid;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
public String getCapabilities() {
return capabilities;
}
public void setCapabilities(String capabilities) {
if (WIFI_AUTH_OPEN.equals(capabilities)|| WIFI_AUTH_ROAM.equals(capabilities)) {
setEncrypt(-1);
}
//WifiConfiguration.KeyMgmt
this.capabilities = capabilities;
}
public int getEncrypt() {
return encrypt;
}
public void setEncrypt(int encrypt) {
this.encrypt = encrypt;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static WiFiItem obtain(@NonNull ScanResult result, int state){
WiFiItem item = new WiFiItem();
item.setSsid(result.SSID);
item.setBssid(result.BSSID);
item.setState(state);
item.setLevel(result.level);
item.setCapabilities(result.capabilities);
item.setData(result);
return item;
}
public static String ssid(String str){
return str == null ? "" : str.replace("\"","");
}
}
话不多说，这个还是很简单的，就是把一些展示的时候可能用到的数据给它封装一下。
3.监听wifi状态的广播，用于更新UI，比较重要也比较关键
/**
* 监听wifi的广播
*/
public class WifiPresenter implements Handler.Callback {
private static final String TAG = "WifiPresenter";
private static final long DELAY = 1000;
private Handler mHandler;
private WeakReference<WifiHelper> mHelper;
private static final int CONNECTED_WHAT = 120;
private static final int DISCONNECT_WHAT = 121;
private static final int CONNECTING_WHAT = 122;
private static final int ERROR_PASSWORD_WHAT = 123;
public WifiPresenter(WifiHelper helper){
this.mHelper = new WeakReference<WifiHelper>(helper);
mHandler = new Handler(Looper.getMainLooper(), this);
}
private WifiHelper getHelper(){
return mHelper.get();
}
private BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
switch (intent.getAction()){
case WifiManager.SUPPLICANT_STATE_CHANGED_ACTION:
handleSupplicantStateChanged(
(SupplicantState) intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE),
intent.hasExtra(WifiManager.EXTRA_SUPPLICANT_ERROR),
intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, 0));
break;
case WifiManager.NETWORK_STATE_CHANGED_ACTION:
Parcelable parcelable = intent
.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
if (parcelable != null) {
NetworkInfo networkInfo = (NetworkInfo) parcelable;
String SSID = networkInfo.getExtraInfo();
switch (networkInfo.getState()) {
/*
* 正在连接
*/
case CONNECTING:
Log.i(TAG,"===CONNECTING==ssid="+SSID);
if (SSID != null && !SSID.equals("<unknown ssid>") && !SSID.equals("0x")) {
mHandler.removeMessages(CONNECTING_WHAT);
mHandler.sendMessageDelayed(
mHandler.obtainMessage(CONNECTING_WHAT, SSID),
DELAY);
}
break;
case UNKNOWN:
Log.i(TAG,"===UNKNOWN==ssid="+SSID);
break;
/*
* 连接成功
*/
case CONNECTED:
Log.i(TAG,"===CONNECTED==ssid="+SSID);
if (SSID != null && !SSID.equals("<unknown ssid>") && !SSID.equals("0x")) {
mHandler.removeMessages(CONNECTED_WHAT);
mHandler.sendMessageDelayed(
mHandler.obtainMessage(CONNECTED_WHAT, SSID),
DELAY);
}
break;
/*
* 连接失败
*/
case DISCONNECTED:
Log.i(TAG,"===DISCONNECTED==ssid="+SSID);
if (SSID != null && !SSID.equals("<unknown ssid>") && !SSID.equals("0x")) {
mHandler.removeMessages(DISCONNECT_WHAT);
mHandler.sendMessageDelayed(mHandler.obtainMessage(DISCONNECT_WHAT,
SSID), DELAY);
break;
}
default:
break;
}
}
break;
}
}
};
public void start(){
IntentFilter filter = new IntentFilter();
filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
getHelper().register(receiver,filter);
}
private void handleSupplicantStateChanged(SupplicantState state, boolean hasError, int error) {
if (hasError && error == 1)
getHelper().error(error);
}
@Override
public boolean handleMessage(Message msg) {
switch (msg.what){
case CONNECTED_WHAT:
getHelper().success(WifiItem.ssid((String) msg.obj));
break;
case DISCONNECT_WHAT:
getHelper().disConnect(WifiItem.ssid((String) msg.obj));
break;
case CONNECTING_WHAT:
getHelper().connecting(WifiItem.ssid((String) msg.obj));
break;
}
return false;
}
public void destroy(){
mHandler.removeCallbacksAndMessages(null);
getHelper().unregister(receiver);
mHelper.clear();
}
这里我们通过广播去监听wifi改变的状态，同时通过回调的方式去通知UI那边进行更新，我们只需要在主Activity那边去实现接口的方法就可以了。接下来是WiFiHelper接口类。
4.WifiHelper类
public interface WifiHelper {
/**
* 注册广播
* @param receiver
* @param filter
*/
void register(BroadcastReceiver receiver, IntentFilter filter);
/**
* 取消注册
* @param receiver
*/
void unregister(BroadcastReceiver receiver);
/**
* wifi连接成功
* @param ssid 当前连接wifi的ssid
*/
void success(String ssid);
/**
* wifi连接失败，可能是密码错误
* @param errorCode
*/
void error(int errorCode);
/**
* wifi 连接中
*/
void connecting(String ssid);
/**
* 断开连接
* @param ssid
*/
void disConnect(String ssid);
}
5.使用RecyclerView之前的一些准备工作
（1）定义BaseBean和WifiBean(列表项)、OpenBean(开启wifi项)、TopBean(头部项)、DividerBean(分割线项)
/**
* BaseBean
*/
public interface BaseBean {
int OPEN = 10;
int DIVIDER = 11;
int TOP = 12;
int WIFI = 13;
int getItemViewType();
void onBindViewHolder(WiFiHolder holder, int position);
}
/**
*DividerBean分割线项
*/
public class DividerBean implements BaseBean {
@Override
public int getItemViewType() {
return DIVIDER;
}
@Override
public void onBindViewHolder(WiFiHolder holder, int position) {
}
}
/**
*OpenBean开启wifi项
*/
public class OpenBean implements BaseBean {
private CallBack<Boolean> call;
private boolean isOpen;
public OpenBean(CallBack<Boolean> call,boolean isOpen) {
this.call = call;
this.isOpen = isOpen;
}
public void setOpen(boolean open) {
isOpen = open;
}
@Override
public int getItemViewType() {
return OPEN;
}
@Override
public void onBindViewHolder(WiFiHolder holder, int position) {
ChoiceView choice = (ChoiceView) holder.getView(R.id.choice);
choice.setSelect(isOpen);
choice.setCallBack(call);
}
}
/**
* wifi头部项（这个其实就是连接的wifi啊，或者选取附近的wifi啊什么的）
*/
public class TopBean implements BaseBean {
private String name;
public TopBean(String name) {
this.name = name;
}
@Override
public int getItemViewType() {
return TOP;
}
@Override
public void onBindViewHolder(WiFiHolder holder, int position) {
TextView txt = holder.getText(R.id.name);
if (txt != null)
txt.setText(name);
}
}
/**
* WiFiBean列表项
*/
public class WiFiBean implements BaseBean {
private GenericCallBack<WifiItem> callBack;
private WifiItem wifi;
public WiFiBean(WifiItem wifi, GenericCallBack<WifiItem> callBack) {
this.wifi = wifi;
this.callBack = callBack;
}
public WifiItem getWifi() {
return wifi;
}
@Override
public void onBindViewHolder(WiFiHolder holder, int position) {
if (holder == null) return;
TextView ssid = holder.getText(R.id.wifi_name);
if (ssid != null)
ssid.setText(wifi.getSsid());
TextView state = holder.getText(R.id.wifi_state);
if (state != null){
String result = "";
if (state.getVisibility() == View.GONE){
state.setVisibility(View.VISIBLE);
}
if (wifi.getState() == WifiItem.CONNECTED){
result = "Connected";
state.setText(result);
}else if (wifi.getState() == WifiItem.SAVED){
result = "Saved";
state.setText(result);
}else if (wifi.getState() == WifiItem.CONNECTING){
result = "Connecting";
state.setText(result);
}else {
state.setVisibility(View.GONE);
}
}
ImageView levelIv = holder.getImage(R.id.wifi_level);
if (levelIv != null){
// Wifi 描述
String desc = "";
String descOri = wifi.getCapabilities();
if (descOri.toUpperCase().contains("WPA-PSK")) {
desc = "WPA";
}
if (descOri.toUpperCase().contains("WPA2-PSK")) {
desc = "WPA2";
}
if (descOri.toUpperCase().contains("WPA-PSK")
&& descOri.toUpperCase().contains("WPA2-PSK")) {
desc = "WPA/WPA2";
}
int level = wifi.getLevel();
if (TextUtils.isEmpty(desc)) {
// desc = "未受保护的网络";
// 网络信号强度
int imgId;
if (Math.abs(level) > 100) {
imgId = R.drawable.icon_wifi_1;
} else if (Math.abs(level) > 80) {
imgId = R.drawable.icon_wifi_1;
} else if (Math.abs(level) > 70) {
imgId = R.drawable.icon_wifi_1;
} else if (Math.abs(level) > 60) {
imgId = R.drawable.icon_wifi_2;
} else if (Math.abs(level) > 50) {
imgId = R.drawable.icon_wifi_2;
} else {
imgId = R.drawable.icon_wifi_3;
}
levelIv.setImageResource(imgId);
} else {
int imgId;
if (Math.abs(level) > 100) {
imgId = R.drawable.icon_wifi_1_locked;
} else if (Math.abs(level) > 80) {
imgId = R.drawable.icon_wifi_1_locked;
} else if (Math.abs(level) > 70) {
imgId = R.drawable.icon_wifi_1_locked;
} else if (Math.abs(level) > 60) {
imgId = R.drawable.icon_wifi_2_locked;
} else if (Math.abs(level) > 50) {
imgId = R.drawable.icon_wifi_2_locked;
} else {
imgId = R.drawable.icon_wifi_3_locked;
}
levelIv.setImageResource(imgId);
}
}
holder.setItemOnClick(new View.OnClickListener() {
@Override
public void onClick(View v) {
callBack.back(wifi);
}
});
}
}
(2).通用的泛型CallBack
public interface CallBack<T> {
boolean back(T t);
}
(3).Adapter和Holder都是老套路，不懂的小朋友可以去百度一波，很多博客写那个的。
public class WiFiAdapter extends RecyclerView.Adapter<WiFiHolder> {
private List<BaseBean> data;
private LayoutInflater inflater;
public WiFiAdapter(List<BaseBean> data, LayoutInflater inflater) {
this.data = data;
this.inflater = inflater;
}
public void connect(String ssid){
for (BaseBean bean:data){
if (bean instanceof WiFiBean){
if (TextUtils.equals(ssid,((WiFiBean) bean).getWifi().getSsid())){
((WiFiBean) bean).getWifi().setState(WifiItem.CONNECTED);
return;
}
}
}
}
public void connecting(String ssid){
for (BaseBean bean:data){
if (bean instanceof WiFiBean){
if (TextUtils.equals(ssid,((WiFiBean) bean).getWifi().getSsid())){
((WiFiBean) bean).getWifi().setState(WifiItem.CONNECTING);
return;
}
}
}
}
public void disConnect(String ssid){
for (BaseBean bean:data){
if (bean instanceof WiFiBean){
if (TextUtils.equals(ssid,((WiFiBean) bean).getWifi().getSsid())){
((WiFiBean) bean).getWifi().setState(WifiItem.SAVED);
return;
}
}
}
}
public List<WifiItem> getWifis(){
List<WifiItem> wifis = new ArrayList<>();
for (BaseBean bean:data){
if (bean instanceof WiFiBean){
wifis.add(((WiFiBean) bean).getWifi());
}
}
return wifis;
}
public List<BaseBean> getData() {
return data;
}
public void setData(List<BaseBean> data) {
this.data = data;
}
@Override
public WiFiHolder onCreateViewHolder(ViewGroup parent, int viewType) {
WiFiHolder holder = null;
holder = new WiFiHolder(inflater.inflate(R.layout.fm_wifi_list_item,parent,false));
return holder;
}
@Override
public void onBindViewHolder(WiFiHolder holder, int position) {
data.get(position).onBindViewHolder(holder,position);
}
@Override
public int getItemCount() {
if (data != null)
return data.size();
return 0;
}
public class WiFiHolder extends RecyclerView.ViewHolder {
private SparseArray<View> views;
private View rootView;
public WiFiHolder(View itemView) {
super(itemView);
rootView = itemView;
views = new SparseArray<>();
}
public TextView getText(int id){
View view = views.get(id);
if (view == null){
view = rootView.findViewById(id);
if (view != null) {
views.put(id, view);
}
}
if (view != null && view instanceof TextView){
return (TextView) view;
}
return null;
}
public View getView( int id ){
View view = views.get(id);
if (view == null){
view = rootView.findViewById(id);
if (view != null) {
views.put(id, view);
}
}
if (view != null){
return view;
}
return null;
}
public ImageView getImage(int id){
View view = views.get(id);
if (view == null){
view = rootView.findViewById(id);
if (view != null) {
views.put(id, view);
}
}
if (view != null && view instanceof ImageView){
return (ImageView) view;
}
return null;
}
public void setItemOnClick(View.OnClickListener listener){
rootView.setOnClickListener(listener);
}
public void setViewOnClick(int id,View.OnClickListener listener){
View view = views.get(id);
if (view != null)
view.setOnClickListener(listener);
}
}
6.接下来是WifiConfigActivity了
public class MainActivity extends AppCompatActivity implements View.OnClickListener,WifiHelper,Handler.Callback{
private static final String TAG = "MainActivity";
private Context context;
private ImageView back;
private ImageView refresh_img;
private RotateAnimation rotate;
private RecyclerView recycler;
private PassWordDialog dialog ;
ArrayList<BaseBean> wifis = new ArrayList<>();
private WiFiAdapter adapter;
private Handler handler;
private WifiPresenter presenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
context = this;
handler = new Handler(this);
dialog = new PassWordDialog(context);
back = (ImageView) findViewById(R.id.back);
refresh_img = (ImageView) findViewById(R.id.refresh_img);
recycler = (RecyclerView) findViewById(R.id.recycler);
recycler.setLayoutManager(new LinearLayoutManager(this));
adapter = new WiFiAdapter(wifis, getLayoutInflater());
recycler.setAdapter(adapter);
back.setOnClickListener(this);
refresh_img.setOnClickListener(this);
rotate = new RotateAnimation(0,360, Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f);
rotate.setRepeatCount(-1);
rotate.setInterpolator(new LinearInterpolator());
rotate.setDuration(1000);
//向bean里面添加格式各样的不同类型的样式布局
wifis.add(new OpenBean(new CallBack<Boolean>() {
@Override
public boolean back(Boolean aBoolean) {
wifiManager(context).setWifiEnabled(aBoolean);
if (aBoolean){
handler.sendEmptyMessageDelayed(100,2000);
}else {
BaseBean baseBean = wifis.get(0);
if (baseBean instanceof OpenBean){
((OpenBean) baseBean).setOpen(false);
}
wifis.clear();
wifis.add(baseBean);
adapter.notifyDataSetChanged();
}
return false;
}
},wifiManager(this).isWifiEnabled()));
presenter = new WifiPresenter(this);
presenter.start();
}
/**
*根据扫描出的wifi列表进行分类处理，以用于展示在不同的子item目录下
*/
private void resolve(List<WiFiItem> data){
if (data.size() > 0){
BaseBean baseBean = wifis.get(0);
wifis.clear();
wifis.add(baseBean);
wifis.add(new DividerBean());
wifis.add(new TopBean("连接的WLAN"));
Iterator<WiFiItem> iterator = data.iterator();
while (iterator.hasNext()){
WiFiItem next = iterator.next();
if (next.getState() == WiFiItem.CONNECT || WiFiItem.CONNECTING == next.getState()){
wifis.add(3,new WiFiBean(next,callBack));
}else if (next.getState() == WiFiItem.SAVED){
wifis.add(new WiFiBean(next,callBack));
}
}
wifis.add(new DividerBean());
wifis.add(new TopBean("选取附近的WLAN"));
for (WiFiItem item:data){
if (item.getState() == WiFiItem.SCAN){
wifis.add(new WiFiBean(item,callBack));
}
}
adapter.notifyDataSetChanged();
}else {
adapter.notifyItemMoved(1,wifis.size());
}
}
@Override
protected void onResume() {
super.onResume();
resolve(WifiUtil.scanWifi(context));
}
@Override
public void onClick(View v) {
if (v == back){
finish();
}else if (refresh_img == v){
refresh_img.startAnimation(rotate);
handler.sendEmptyMessageDelayed(102,1000);
}
}
@Override
public void register(BroadcastReceiver receiver, IntentFilter filter) {
registerReceiver(receiver,filter);
}
@Override
public void unregister(BroadcastReceiver receiver) {
unregisterReceiver(receiver);
}
@Override
public void success(String ssid) {
adapter.connect(ssid);
resolve(adapter.getWifis());
}
@Override
public void error(int errorCode) {
Toast.makeText(context,"密码错误",Toast.LENGTH_SHORT).show();
}
@Override
public void connecting(String ssid) {
adapter.connecting(ssid);
resolve(adapter.getWifis());
}
@Override
public void disConnect(String ssid) {
adapter.disConnect(ssid);
resolve(adapter.getWifis());
}
@Override
protected void onDestroy() {
super.onDestroy();
presenter.destroy();
}
private CallBack<WiFiItem> callBack = new CallBack<WiFiItem>() {
@Override
public boolean back(final WiFiItem wiFiItem) {
if (wiFiItem.getState() == WiFiItem.CONNECT || wiFiItem.getState() == WiFiItem.CONNECTING){
return true;
}
if (wiFiItem.getState() == WiFiItem.SAVED){
WiFiUtil.connectWiFi(context,wiFiItem.getSsid(),null);
}
if (wiFiItem.getState() == WiFiItem.SCAN){
if (wiFiItem.getEncrypt() == -1){
WiFiUtil.connectWiFi(context,wiFiItem.getSsid(),"");
}else {
dialog.setPsd("");
dialog.setTitle(wiFiItem.getSsid());
dialog.show();
dialog.setOnclick(new View.OnClickListener() {
@Override
public void onClick(View v) {
dialog.dismiss();
}
}, new View.OnClickListener() {
@Override
public void onClick(View v) {
dialog.dismiss();
WiFiUtil.connectWiFi(context,wiFiItem.getSsid(),dialog.getPsd());
}
});
}
}
return false;
}
};
写到这里就差不多完了，可能还会有什么漏掉的地方。其实我也有写手动添加wifi，然后去连接wifi的情况（此代码里面没有反应出来，不过很简单，大家可以试着写一下，时间关系就不一一写出来了），之前因为前人写的代码，所以走了一点弯路，及时改正过来了，就是在creadWifiInfo的时候WPA的config里面，有个参数设置之后就连接不成功，后来经过改进，改进的代码已经写到了这个例子里面去了，大家可以参考一下。
纯手打的博客，第二次写博客，写得特别乱，大家将就看一下吧。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
