Android WIFI 开发

公司之前业务需要，APP内需要实现搜索wifi，连接wifi等操作。在网上找了很多资料，终于做了出来，现在提取出来部分功能写成demo,和大家分享。先看图：

下面来看看主要wifi操作代码WifiAdmin.java：
PS:这个名字我看网络上都用，我也用了。使用的WifiManager类，其中的创建热点部分被隐藏了，可以用反射实现热点功能。配置WifiConfiguration进行连接时，无密码wifi和加密的处理是有些不一样的，网上千篇一律的全是一样的，然后我就被坑了，无密码的一直不能有，还好google到了原因。

连接步骤：搜索—-判断指定wifi是否有配置好的WifiConfiguration—-有进行连接；没有手动配置进行连接。
如下图：

WifiAdmin.java:

package com.example.wificonnect;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.WifiLock;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;

/**
 * WIFI管理
 * 
 * @author xugang
 * 
 */
public class WifiAdmin {
    // WifiManager对象
    private WifiManager mManager;
    // WifiInfo对象
    private WifiInfo mWifiInfo;
    // 网络设置列表
    private List<WifiConfiguration> mConfigurations;
    // Wifi锁
    private WifiLock mWifiLock;
    private ConnectivityManager connManager;

    /** 开始搜索 */
    public static final int scan = 0;
    /** 开始得到结果 */
    public static final int restult = 1;
    /** 暂停 */
    public static final int onStop = 2;
    /** 销毁 */
    public static final int onDestroy = 3;
    /** 打开wifi */
    public static final int open = 4;
    /** 找到 需要的WIFI */
    public static final int connect = 5;
    /** 正在连接 */
    public static final int connecting = 6;
    /** 已连接 */
    public static final int connected = 7;
    /** 搜索超时 */
    public static final int OutOfTime = 8;

    private static WifiAdmin admin;
    public static final int WPA_PSK = 3;
    public static final int WEP = 2;
    public static final int NO_PWD = 1;

    private OnWifiConnectListener onWifiConnectListener;

    private Context mContext;

    public void setOnWifiConnectListener(OnWifiConnectListener onWifiConnectListener) {
        this.onWifiConnectListener = onWifiConnectListener;
    }

    private WifiAdmin(Context context) {
        this.mContext = context;
        this.mManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        mWifiInfo = mManager.getConnectionInfo();
        mConfigurations = new ArrayList<WifiConfiguration>();
        connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    public static WifiAdmin getInstance(Context context) {
        if (admin == null) {
            admin = new WifiAdmin(context);
        }
        return admin;
    }

    /** 获取当前连接信息 */
    public WifiInfo getConnectionInfo() {
        if (!isConnectWifi())
            return null;
        mWifiInfo = mManager.getConnectionInfo();
        return mWifiInfo;
    }

    /** 判断当前WIFI是否连接 */
    public boolean isConnectWifi() {
        NetworkInfo mInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        return mInfo.isConnected();
    }

    /** 获取MAC */
    public String getMac() {
        mWifiInfo = mManager.getConnectionInfo();
        return mWifiInfo.getMacAddress();
    }

    /**
     * 更具指定名称筛选WIFI列表
     * 
     * @param cs
     * @return
     */
    public List<ScanResult> getScanResult() {
        return mManager.getScanResults();
    }

    /**
     * 获得WifiConfiguration列表
     * 
     * @param cs
     * @return
     */
    public List<WifiConfiguration> getConfigurations() {
        mConfigurations = mManager.getConfiguredNetworks();
        return mConfigurations;
    }

    public boolean isWifiEnabled() {
        return mManager.isWifiEnabled();
    }

    // 判定指定WIFI是否已经配置好,依据WIFI的地址SSID,返回NetId
    public int IsConfiguration(String SSID) {
        for (int i = 0; i < mConfigurations.size(); i++) {
            if (mConfigurations.get(i).SSID.equals("\"" + SSID + "\"")) {// 地址相同
                return mConfigurations.get(i).networkId;
            }
        }
        return -1;
    }

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

    /**
     * 搜索Wifi
     */
    public boolean startScan() {
        openWifi();
        return mManager.startScan();
    }

    /**
     * 关闭WIfi
     */
    public void closeWifi() {
        if (!mManager.isWifiEnabled()) {
            mManager.setWifiEnabled(false);
        }
    }

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

    /**
     * 释放锁
     */
    public void releaseWifiLock() {
        if (mWifiLock.isHeld()) {
            mWifiLock.release();
        }
    }

    /**
     * 创建一个WifiLock
     */
    public void createWifiLock() {
        mWifiLock = mManager.createWifiLock("wifiAdmin");
    }

    // 连接配置好的网络
    public void connectConfiguration(WifiConfiguration config) {
        int netid = mManager.addNetwork(config);
        boolean res = connectNetId(netid);
        if (onWifiConnectListener != null) {
            onWifiConnectListener.onWifiConnect(res);
        }
    }

    // 连接指定netId的WIFI
    public boolean connectNetId(int netId) {
        boolean res = mManager.enableNetwork(netId, true);
        return res;
    }

    public interface OnWifiConnectListener {
        public void onWifiConnect(boolean res);
    }

    /**
     * 指定配置好的网络连接
     * 
     * @param index
     */
    public void connectConfiguration(int index) {
        if (index > mConfigurations.size()) {
            return;
        }
        mManager.enableNetwork(mConfigurations.get(index).networkId, true);
    }

    // 连接
    public void connect(final ScanResult result) {
        getConfigurations();
        int netId = IsConfiguration(result.SSID);
        if (netId != -1) {
            showConnectWiFiWithoutPwd(result.SSID, netId);
            return;
        }
        if (result.capabilities.contains("WPA")) {
            // wpa-psk加密
            showConnectWiFiWithPwd(result.SSID, WPA_PSK);
        } else if (result.capabilities.contains("WEP")) {
            // wep加密
            showConnectWiFiWithPwd(result.SSID, WEP);
        } else {
            // 未加密
            showConnectWiFiWithoutPwd(result.SSID, -1);
        }
    }

    // 生成WifiConfiguration
    public WifiConfiguration createWifiInfo(String SSID, String Password, int Type) {
        WifiConfiguration localWifiConfiguration1 = new WifiConfiguration();
        localWifiConfiguration1.allowedAuthAlgorithms.clear();
        localWifiConfiguration1.allowedGroupCiphers.clear();
        localWifiConfiguration1.allowedKeyManagement.clear();
        localWifiConfiguration1.allowedPairwiseCiphers.clear();
        localWifiConfiguration1.allowedProtocols.clear();
        localWifiConfiguration1.SSID = ("\"" + SSID + "\"");
        WifiConfiguration localWifiConfiguration2 = isExsits(SSID);
        if (localWifiConfiguration2 != null)
            mManager.removeNetwork(localWifiConfiguration2.networkId);
        //下面几个是开放wifi和非开放wifi的配置方式，经测试不管是开放的和不开放的都能链接
        if (Type == NO_PWD) {
            localWifiConfiguration1.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        } else if (Type == WEP) {
            localWifiConfiguration1.hiddenSSID = true;
            localWifiConfiguration1.wepKeys[0] = ("\"" + Password + "\"");
        } else {
            localWifiConfiguration1.preSharedKey = ("\"" + Password + "\"");
            localWifiConfiguration1.hiddenSSID = true;
            localWifiConfiguration1.allowedAuthAlgorithms.set(0);
            localWifiConfiguration1.allowedGroupCiphers.set(2);
            localWifiConfiguration1.allowedKeyManagement.set(1);
            localWifiConfiguration1.allowedPairwiseCiphers.set(1);
            localWifiConfiguration1.allowedGroupCiphers.set(3);
            localWifiConfiguration1.allowedPairwiseCiphers.set(2);
        }
        return localWifiConfiguration1;
    }

    // 返回指定SSID的WifiConfiguration
    private WifiConfiguration isExsits(String SSID) {
        Iterator<WifiConfiguration> localIterator = this.mManager.getConfiguredNetworks().iterator();
        WifiConfiguration localWifiConfiguration;
        do {
            if (!localIterator.hasNext())
                return null;
            localWifiConfiguration = (WifiConfiguration) localIterator.next();
        } while (!localWifiConfiguration.SSID.equals("\"" + SSID + "\""));
        return localWifiConfiguration;
    }

    // 显示连接Wifi弹框，需要输入密码
    private void showConnectWiFiWithPwd(final String ssid, final int type) {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        LayoutInflater inflater = LayoutInflater.from(mContext);
        View view = inflater.inflate(R.layout.dialog_sgin, null);
        final TextView name = (TextView) view.findViewById(R.id.name);
        final EditText password = (EditText) view.findViewById(R.id.password);
        name.setText(ssid);
        builder.setView(view).setPositiveButton(R.string.connect, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int id) {
                String pwd = password.getText().toString().trim();
                if (!TextUtils.isEmpty(pwd))
                    connectConfiguration(createWifiInfo(ssid, pwd, type));
            }
        }).setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                dialog.cancel();
            }
        });
        builder.create().show();
    }

    // 显示连接Wifi弹框，不需要输入密码
    private void showConnectWiFiWithoutPwd(final String ssid, final int type) {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        LayoutInflater inflater = LayoutInflater.from(mContext);
        View view = inflater.inflate(R.layout.dialog_sgin_open, null);
        final TextView name = (TextView) view.findViewById(R.id.name);
        name.setText(ssid);
        builder.setView(view).setPositiveButton(R.string.connect, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int id) {
                switch (type) {
                case -1:
                    connectConfiguration(createWifiInfo(ssid, "", type));
                    break;
                default:
                    connectNetId(type);
                    break;
                }
            }
        }).setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                dialog.cancel();
            }
        });
        builder.create().show();
    }

}

适配器基类：

package com.example.wificonnect.adapter;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;

import com.lidroid.xutils.ViewUtils;

/**
 * @ClassName CommonAdapter.java
 * @Description 公用Adapter , 能满足基本需求,使用时直接集成此类和BaseViewHolder</br>已经重用item的View
 * @author xugang
 * @date 2015-8-14 下午12:25:27
 */
public abstract class CommonAdapter<T> extends BaseAdapter {

    public List<T> mList;
    private LayoutInflater mInflater;

    public CommonAdapter(Context context) {
        this(context, null);
    }

    public CommonAdapter(Context context, List<T> mList) {
        if (mList != null)
            this.mList = mList;
        else {
            this.mList = new ArrayList<T>();
        }
        mInflater = LayoutInflater.from(context);
    }

    public void addObjToList(T t) {
        if (t != null) {
            mList.add(t);
        }
    }

    public void addObjToList(int position, T t) {
        if (t != null) {
            mList.add(position, t);
        }
    }

    public void addArraysToList(List<T> list) {
        if (list != null) {
            mList.addAll(list);
        }
    }

    public void setArrayToList(List<T> list) {
        if (list != null) {
            mList = list;
        }
    }

    @Override
    public int getCount() {
        return mList == null ? 0 : mList.size();
    }

    @Override
    public Object getItem(int position) {
        return mList == null ? null : mList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @SuppressWarnings("unchecked")
    @Override
    public View getView(int position, View view, ViewGroup parent) {
        BaseViewHolder holder;
        if (view == null) {
            view = mInflater.inflate(setItemLayoutId(), parent, false);
            holder = setViewHolder();
            ViewUtils.inject(holder, view);
            view.setTag(holder);
        } else {
            holder = (BaseViewHolder) view.getTag();
        }
        holder.inflaterContent(position);

        return view;
    }

    /**
     * 添加item布局
     */
    public abstract int setItemLayoutId();

    /**
     * 设置ViewHolder
     */
    public abstract BaseViewHolder setViewHolder();

    public abstract class BaseViewHolder {
        /**
         * 在此方法里填充内容
         */
        public abstract void inflaterContent(int position);

    }

}

以下WifiAdapter:
需要注意的是注意判断是否为加密WIfi

package com.example.wificonnect.adapter;

import com.example.wificonnect.R;
import com.example.wificonnect.WifiAdmin;
import com.lidroid.xutils.view.annotation.ViewInject;

import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.widget.ImageView;
import android.widget.TextView;

/**
 * @project WiFiConnect
 * @ClassName WifiAdapter.java
 * @Description  Wifi适配器
 * @author xugang
 * @date 2015-8-18 下午5:11:10
 */
public class WifiAdapter<T> extends CommonAdapter<T> {
    private WifiAdmin wifiAdmin;

    public WifiAdapter(Context context) {
        super(context);
        wifiAdmin = WifiAdmin.getInstance(context);
    }

    @Override
    public int setItemLayoutId() {
        return R.layout.item;
    }

    @Override
    public BaseViewHolder setViewHolder(int position) {
        return new ViewHolder();
    }

    class ViewHolder extends BaseViewHolder {
        @ViewInject(R.id.wifi_name)
        private TextView wifi_name;
        @ViewInject(R.id.wifi_state)
        private TextView wifi_state;
        @ViewInject(R.id.wifi_indicate)
        private ImageView wifi_indicate;


        @Override
        public void inflaterContent(int position) {
            ScanResult scanResult = (ScanResult) mList.get(position);
            wifi_name.setText(scanResult.SSID);
            WifiInfo wifiInfo = wifiAdmin.getConnectionInfo();
            setLevel(scanResult);
            if (wifiInfo == null) {
                wifi_state.setText("未连接");
            } else {
                if (wifiInfo.getSSID().equals("\"" + scanResult.SSID + "\"")) {
                    wifi_state.setText("已连接");
                } else {
                    wifi_state.setText("未连接");
                }
            }
        }

        public void setLevel(ScanResult scanResult) {
            int level = WifiManager.calculateSignalLevel(scanResult.level, 4);
            int imgId = R.drawable.ic_wifi_signal_lock_1;
            if (scanResult.capabilities.contains("WEP") || scanResult.capabilities.contains("WPA")) {
                switch (level) {
                case 0:
                    imgId = R.drawable.ic_wifi_signal_lock_1;
                    break;
                case 1:
                    imgId = R.drawable.ic_wifi_signal_lock_2;
                    break;
                case 2:
                    imgId = R.drawable.ic_wifi_signal_lock_3;
                    break;
                case 3:
                    imgId = R.drawable.ic_wifi_signal_lock_4;
                    break;
                }
            } else {
                switch (level) {
                case 0:
                    imgId = R.drawable.ic_wifi_signal_open_1;
                    break;
                case 1:
                    imgId = R.drawable.ic_wifi_signal_open_2;
                    break;
                case 2:
                    imgId = R.drawable.ic_wifi_signal_open_3;
                    break;
                case 3:
                    imgId = R.drawable.ic_wifi_signal_open_4;
                    break;
                }
            }
            wifi_indicate.setImageResource(imgId);
        }

    }

}

在Activity中使用，需要注册广播来获取wifi变化消息，如下：

package com.example.wificonnect;

import com.example.wificonnect.adapter.WifiAdapter;
import com.lidroid.xutils.ViewUtils;
import com.lidroid.xutils.view.annotation.ViewInject;

import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;

public class MainActivity extends Activity implements OnClickListener, OnItemClickListener {
    private WifiAdmin wifiAdmin;
    private WifiBroadcastReceiver broadcastReceiver;
    private WifiAdapter<ScanResult> mAdapter;
    @ViewInject(R.id.lv)
    private ListView lv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ViewUtils.inject(this);
        findViewById(R.id.refresh).setOnClickListener(this);
        wifiAdmin = WifiAdmin.getInstance(this);
        mAdapter = new WifiAdapter<ScanResult>(this);
        lv.setAdapter(mAdapter);
        lv.setOnItemClickListener(this);
        registerWifiReceiver();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(broadcastReceiver);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.refresh:
            wifiAdmin.startScan();
            break;

        default:
            break;
        }
    }

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        ScanResult scanResult = (ScanResult) parent.getItemAtPosition(position);
        wifiAdmin.connect(scanResult);
    };

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case WifiAdmin.restult:
                mAdapter.setArrayToList(wifiAdmin.getScanResult());
                mAdapter.notifyDataSetChanged();
                break;
            case WifiAdmin.OutOfTime:

                break;
            default:
                break;
            }
        }
    };

    /**
     * 注册广播Wifi变化
     */
    private void registerWifiReceiver() {
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        broadcastReceiver = new WifiBroadcastReceiver();
        this.registerReceiver(broadcastReceiver, intentFilter);
    }
    //广播接收wifi变化
    public class WifiBroadcastReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            // ScanResult
            if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)) {
                handler.sendEmptyMessage(WifiAdmin.restult);
            } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {
                // // 网络连接变化
                System.out.println("-----------已切换");
                mAdapter.notifyDataSetChanged();
            } else if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {
                System.out.println("-----------WiFi状态变化");
            }
        }
    }
}

项目demo：http://download.csdn.net/detail/hello_12413/9021927