讓手機連接到指定的WIFI網絡，適用於之前已經連過的網絡

這個例子是從網上找的，我給重新優化了下。這里有個問題是只能連接到之前已經連接過的wifi，目前還沒找到連接到陌生wifi（有/無密碼）的方法。總之慢慢來吧~

說下思路：

1.通過wifiManager來查找想要鏈接的wifi是否是之前已經連過的，如果是就進行下一步

2.查找想要鏈接的wifi名字是否在可搜索的范圍內，也就是當前是否可以搜到，如果能搜到就可以連接了

3.通過WifiManager.enableNetwork(getWifiConfigurated(wifi_SSID), true);來連接到指定網絡

PS：這里動態注冊了一個廣播來監聽wifi的變化，能比較直觀的現實wifi的變化

MainActivity.java

package com.example.testforwifilinkdemo;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class LinkWifiActivity extends Activity {

    private WifiAdmin wifiAdmin;
     //這里寫想要鏈接的wifi名字
    private final static String TAG_SSID = "CMCC-EDU";
    
    //判斷是否連接上制定的wifi
    private boolean isConnected = false;
    
    private BroadcastReceiver wifiConnectReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_link_wifi);

        wifiAdmin = new WifiAdmin(LinkWifiActivity.this);

        wifiConnectReceiver = new WifiConnectReceiver();
        
        IntentFilter filter = new IntentFilter();
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        LinkWifiActivity.this.registerReceiver(wifiConnectReceiver, filter);//注冊廣播

        Button linkBtn = (Button) findViewById(R.id.linkWifiBtn);
        linkBtn.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                connectToTagWifi(TAG_SSID);
            }
        });
    }

    class WifiConnectReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
                ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
                NetworkInfo notewokInfo = manager.getActiveNetworkInfo();
                if (notewokInfo != null) {
                    System.out.println("notewokInfo.getExtraInfo()------->"+ notewokInfo.getExtraInfo());
                    WifiInfo currentWifiInfo = wifiAdmin.getCurrentWifiInfo();
                    System.out.println("currentWifiInfo.getSSID()----->"+ currentWifiInfo.getSSID());
                    if (currentWifiInfo.getSSID().equals("\"" + TAG_SSID + "\"")) {
                        isConnected = true;
                    }
                } else {
                    System.out.println("notewokInfo is null");
                }
            }
        }

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        LinkWifiActivity.this.unregisterReceiver(wifiConnectReceiver);//取消廣播
    }
    
    
    /**
     * @param wifi_SSID
     * 關鍵代碼
     */
    public void connectToTagWifi(String wifi_SSID) {
        System.out.println("正在努力連接到指定的wifi");
        wifiAdmin.connectConfiguratedWifi(TAG_SSID);
        
    }
    


}

 

工具類：WifiAdmin.java

package com.example.testforwifilinkdemo;

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

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.net.wifi.WifiManager.WifiLock;
import android.util.Log;

public class WifiAdmin {
    private final static String TAG = "WifiAdmin";
    public static final int IS_OPENING = 1,IS_CLOSING = 2,IS_OPENED = 3,IS_CLOSED = 4;
    
    private StringBuffer mStringBuffer = new StringBuffer();
    private List<ScanResult> scanResultList;
    private ScanResult mScanResult;
    // 定義WifiManager對象
    private WifiManager mWifiManager;
    // 定義WifiInfo對象
    private WifiInfo mWifiInfo;
    // 網絡連接列表
    private List<WifiConfiguration> mWifiConfigList;
    // 定義一個WifiLock
    WifiLock mWifiLock;

    /**
     * 構造方法
     */
    public WifiAdmin(Context context) {
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        mWifiInfo = mWifiManager.getConnectionInfo();
        mWifiConfigList = mWifiManager.getConfiguredNetworks();
    }

    /**
     * 打開Wifi網卡，能打開就返回true，無法打開返回false
     */
    public boolean openNetCard() {
        if (!mWifiManager.isWifiEnabled()) {
            return mWifiManager.setWifiEnabled(true);
        }
        else{
            return false;
        }
    }

    /**
     * 關閉Wifi網卡，能關閉返回true，不能關就返回false
     */
    public boolean closeNetCard() {
        if (mWifiManager.isWifiEnabled()) {
            return mWifiManager.setWifiEnabled(false);
        }
        else{
            return false;
        }
    }

    /**
     * 檢查當前Wifi網卡狀態，返回四種狀態，如果出錯返回-1
     */
    public int getWifitate() {
        int result = -1;
        switch (mWifiManager.getWifiState()) {
        case 0:
            Log.i(TAG, "網卡正在關閉");
            result = IS_CLOSING;
            break;
        case 1:
            Log.i(TAG, "網卡已經關閉");
            result = IS_CLOSED;
            break;
        case 2:
            Log.i(TAG, "網卡正在打開");
            result = IS_OPENING;
            break;
        case 3:
            Log.i(TAG, "網卡已經打開");
            result = IS_OPENED;
            break;
        default:
            Log.i(TAG, "---_---暈......沒有獲取到狀態---_---");
            result = -1;
            break;
        }
        return result;
    }

    /**
     * 掃描周邊網絡，判斷周邊是否有wifi，有就返回true，沒有就返回false
     */
    public boolean scan() {
        if (getWifitate() == IS_OPENED) {
            //開始掃描
            mWifiManager.startScan();
            //將掃描結果存入數據列中
            scanResultList = mWifiManager.getScanResults();
            if (scanResultList != null) {
                return true;
            }
        }
        return false;
    }

    /**
     * 得到附近wifi的掃描結果，是ScanResult對象
     * 得到的是附近網絡的結果集，沒有就返回null
     */
    public ArrayList<ScanResult> getScanResult() {
        // 每次點擊掃描之前清空上一次的掃描結果
        if (mStringBuffer != null) {
            mStringBuffer = new StringBuffer();
        }
        
        scan();// 開始掃描網絡
        ArrayList<ScanResult> scanResultsList = new ArrayList<ScanResult>();
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                mScanResult = scanResultList.get(i);
                scanResultsList.add(mScanResult);
                
                /*mStringBuffer = mStringBuffer.append("NO.").append(i)
                        .append(" :")
                        .append(mScanResult.SSID).append("->")
                        .append(mScanResult.BSSID).append("->")
                        .append(mScanResult.capabilities).append("->")
                        .append(mScanResult.frequency).append("->")
                        .append(mScanResult.level).append("->")
                        .append(mScanResult.describeContents()).append("\n\n");*/
            }
            //Log.i(TAG, mStringBuffer.toString());
            return scanResultsList;
        }
        else {
            return null;
        }
    }
    
    /**
     * 判斷指定的網絡是否能被掃描到
     * @param wifi_SSID
     * @return 如果能夠在周邊發現指定的網絡就返回true，否則返回false
     */
    public boolean canScannable(String wifi_SSID) {
        boolean canScannable = false;
        scan();//開始掃描周邊網絡
        //得到掃描到的wifi列表
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                System.out.println("scanResultList " + i + "----->" + scanResultList.get(i).SSID);
                if (scanResultList.get(i).SSID.equals(wifi_SSID)) {
                    canScannable = true;//如果想要鏈接的wifi能夠掃描到，那么就說明能夠鏈接
                    break;
                }
            }
        }
        return canScannable;
    }
    
    /**
     * 得到指定網絡的index（從0開始計數），找不到就返回-1
     */
    public int getTagWifiId(String netName){
        // 開始掃描網絡
        scan();
        scanResultList = mWifiManager.getScanResults();
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                mScanResult = scanResultList.get(i);
                if(mScanResult.SSID.equals(netName)){
                    return i;
                }
                String show = "No = "+i + 
                        " SSID = "+mScanResult.SSID + 
                        " capabilities = "+mScanResult.capabilities + 
                        " level = "+mScanResult.level;
                Log.i(TAG, show);
            }
        }
        return -1;
    }
    
    /**
     * 斷開當前連接的網絡
     */
    public void disconnectWifi() {
        int netId = getCurrentNetworkId();
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
        mWifiInfo = null;
    }

    /**
     * 檢查當前網絡狀態
     * 如果有wifi鏈接，返回true，如果沒有就返回false
     */
    public boolean getWifiConnectState() {
        return mWifiInfo != null ? true : false;
    }
    
    /**
     * @return 當前網絡的名字，如果沒有就返回null，否則返回string
     */
    public String getCurrentSSID(){
        return (mWifiInfo == null) ? null :mWifiInfo.getSSID();
    }
    
    /**
     * 得到連接的ID，如果沒有就返回0，否則返回正確的id
     */
    public int getCurrentNetworkId() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }

    /**
     * 得到IP地址，出錯時返回0
     */
    public int getCurrentIPAddress() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }
    
    /**
     * 得到MAC地址
     * @return 出錯了返回null
     */
    public String getCurrentMacAddress() {
        return (mWifiInfo == null) ? null : mWifiInfo.getMacAddress();
    }

    /**
     * 得到接入點的BSSID
     * @return 出錯返回null
     */
    public String getCurrentBSSID() {
        return (mWifiInfo == null) ? null : mWifiInfo.getBSSID();
    }

    /**
     * 得到WifiInfo的所有信息包
     * @return 出錯了返回null
     */
    public WifiInfo getCurrentWifiInfo() {
        return (mWifiInfo == null) ? null : mWifiInfo;
    }

    // 鎖定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 mWifiConfigList; 
    }

    /**
     * @param index
     * @return 沒有連接到返回false，正在連接則返回true
     */
    public boolean connectConfiguratedWifi(String wifi_SSID) {
        //如果當前網絡不是想要鏈接的網絡，要連接的網絡是配置過的，並且要連接的網絡能夠被掃描到
        if (getCurrentSSID().indexOf(wifi_SSID) == -1 ) {
            if (getWifiConfigurated(wifi_SSID) != -1 && canScannable(wifi_SSID)) {
                mWifiManager.enableNetwork(getWifiConfigurated(wifi_SSID), true);
            }
            else {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 判斷要連接的wifi名是否已經配置過了
     * @return 返回要連接的wifi的ID，如果找不到就返回-1
     */
    public int getWifiConfigurated(String wifi_SSID) {
        int id = -1;
        if (mWifiConfigList != null) {
            for (int j = 0; j < mWifiConfigList.size(); j++) {
                if (mWifiConfigList.get(j).SSID.equals("\"" + wifi_SSID + "\"")) {
                    //如果要連接的wifi在已經配置好的列表中，那就設置允許鏈接，並且得到id
                    id = mWifiConfigList.get(j).networkId;
                    break;
                }
            }
        }
        return id;
    }

      
   
   

    
}

 

源碼下載：http://download.csdn.net/detail/shark0017/7962497