WIFi

//主界面

public class MainActivity extends Activity implements OnClickListener {  
    public static final String TAG = "MainActivity";  
    private Button scan_wifi;  
    private ListView mlistView;  
    protected WifiAdmin mWifiAdmin;  
    private List<ScanResult> mWifiList;  
    public int level;  
    protected String ssid;  
       
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        mWifiAdmin = new WifiAdmin(MainActivity.this);  
        initViews();  
        IntentFilter filter = new IntentFilter(  
                WifiManager.NETWORK_STATE_CHANGED_ACTION);  
        //="android.net.wifi.STATE_CHANGE"  監聽wifi狀態的變化  
        registerReceiver(mReceiver, filter);  
        mlistView.setOnItemClickListener(new OnItemClickListener() {  
            @Override  
            public void onItemClick(AdapterView<?> parent, View view,  
                    int position, long id) {  
                ScanResult result = mWifiList.get(position);
                ssid=result.SSID;  
                if (!WifiAdmin.isLocked(result)) {
                    mWifiAdmin.addNetwork(mWifiAdmin.CreateWifiInfo(ssid, "", 1));  
                }else{
                    AlertDialog.Builder alert=new AlertDialog.Builder(MainActivity.this);  
                    alert.setTitle(ssid);  
                    alert.setMessage("輸入密碼");  
                    final EditText et_password=new EditText(MainActivity.this);  
                    final SharedPreferences preferences=getSharedPreferences("wifi_password",Context.MODE_PRIVATE);  
                    et_password.setText(preferences.getString(ssid, ""));  
                    alert.setView(et_password);  
                    //alert.setView(view1);  
                    alert.setPositiveButton("連接", new DialogInterface.OnClickListener(){  
                        @Override  
                        public void onClick(DialogInterface dialog, int which) {  
                            String pw = et_password.getText().toString();  
                            if(null == pw  || pw.length() < 8){  
                                Toast.makeText(MainActivity.this, "密碼至少8位", Toast.LENGTH_SHORT).show();  
                                return;      
                            }  
                            Editor editor=preferences.edit();  
                            editor.putString(ssid, pw);   //保存密碼  
                            editor.commit();          
                            mWifiAdmin.addNetwork(mWifiAdmin.CreateWifiInfo(ssid, et_password.getText().toString(), 3));  
                        }  
                    });  
                    alert.setNegativeButton("取消", new DialogInterface.OnClickListener(){  
                        @Override  
                        public void onClick(DialogInterface dialog, int which) {  
                            //  
                            //mWifiAdmin.removeWifi(mWifiAdmin.getNetworkId());  
                        }  
                    });  
                    alert.create();  
                    alert.show();                     
                }  
            }
        });  


    }  
       
    /* 
     * 控件初始化 
     * */  
    private void initViews() {  
        scan_wifi=(Button) findViewById(R.id.scan_wifi);  
        mlistView=(ListView) findViewById(R.id.wifi_list);                


        scan_wifi.setOnClickListener(MainActivity.this);  
    }  
   
    @Override  
    public void onClick(View v) {  
        switch (v.getId()) {  
        case R.id.scan_wifi:  
            mWifiAdmin.startScan(MainActivity.this);  
            mWifiList=mWifiAdmin.getWifiList();  
            if(mWifiList!=null){  
                mlistView.setAdapter(new MyAdapter(this,mWifiList));  
            }  
            break;  
        default:  
            break;  
        }  
    }  
       
    public class MyAdapter extends BaseAdapter{  
        LayoutInflater inflater;  
        List<ScanResult> list;  
        public MyAdapter(Context context, List<ScanResult> list){  
            this.inflater=LayoutInflater.from(context);  
            this.list=list;  
        }  
        @Override  
        public int getCount() {  
            return list.size();  
        }  
        @Override  
        public Object getItem(int position) {  
            return position;  
        }  
        @Override  
        public long getItemId(int position) {  
            return position;  
        }  
        @SuppressLint({ "ViewHolder", "InflateParams" })  
        @Override  
        public View getView(int position, View convertView, ViewGroup parent) {  
            View view=null;  
            view=inflater.inflate(R.layout.wifi_listitem, null);  
            ScanResult scanResult = list.get(position);  
            TextView wifi_ssid=(TextView) view.findViewById(R.id.ssid);  
            ImageView wifi_level=(ImageView) view.findViewById(R.id.wifi_level);  
            wifi_ssid.setText(scanResult.SSID);  
            Log.i(TAG, "scanResult.SSID="+scanResult);  
            level=WifiManager.calculateSignalLevel(scanResult.level,5);  
            if(WifiAdmin.isLocked(scanResult)){  
                wifi_level.setImageResource(R.drawable.wifi_signal_lock);  
            }else{  
                wifi_level.setImageResource(R.drawable.wifi_signal_open);  
            }  
            wifi_level.setImageLevel(level);  
            //判斷信號強度，顯示對應的指示圖標    
             return view;  
        }  
    }  


    //監聽wifi狀態  
    private BroadcastReceiver mReceiver = new BroadcastReceiver (){    
        @Override    
        public void onReceive(Context context, Intent intent) {     
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);    
   
            NetworkInfo wifiInfo = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);     
            if(wifiInfo.isConnected()){  
                WifiManager wifiManager = (WifiManager) context  
                        .getSystemService(Context.WIFI_SERVICE);  
                String wifiSSID = wifiManager.getConnectionInfo()  
                        .getSSID();  
                Toast.makeText(context, wifiSSID+"連接成功", 1).show();  
            }                  
        }     
         
    };   
}

//另一個界面

public class WifiAdmin {  
    // 定義WifiManager對象     
    private 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(Context context) {    
//        if (!mWifiManager.isWifiEnabled()) {    
//            mWifiManager.setWifiEnabled(true);  
//        }else if (mWifiManager.getWifiState() == 2) {  
//            Toast.makeText(context,"親，Wifi正在開啓，不用再開了", Toast.LENGTH_SHORT).show();  
//        }else{  
//            Toast.makeText(context,"親，Wifi已經開啓,不用再開了", Toast.LENGTH_SHORT).show();  
//        }  
//    }    
//     
//    // 關閉WIFI     
//    public void closeWifi(Context context) {    
//        if (mWifiManager.isWifiEnabled()) {    
//            mWifiManager.setWifiEnabled(false);    
//        }else if(mWifiManager.getWifiState() == 1){  
//            Toast.makeText(context,"親，Wifi已經關閉，不用再關了", Toast.LENGTH_SHORT).show();  
//        }else if (mWifiManager.getWifiState() == 0) {  
//            Toast.makeText(context,"親，Wifi正在關閉，不用再關了", Toast.LENGTH_SHORT).show();  
//        }else{  
//            Toast.makeText(context,"請重新關閉", Toast.LENGTH_SHORT).show();  
//        }  
//    }    
//     


     
    // 鎖定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(Context context) {    
        mWifiManager.startScan();    
        // 得到掃描結果        
        List<ScanResult> results = mWifiManager.getScanResults();   
        // 得到配置好的網絡連接     
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();   
        if (results == null) {  //沒有結果
            if(mWifiManager.getWifiState()==3){  
                Toast.makeText(context,"當前區域沒有無線網絡", Toast.LENGTH_SHORT).show();  
            }else if(mWifiManager.getWifiState()==2){  
                Toast.makeText(context,"WiFi正在開啓，請稍後重新點擊掃描", Toast.LENGTH_SHORT).show();  
            }else{  
                Toast.makeText(context,"WiFi沒有開啓，無法掃描", Toast.LENGTH_SHORT).show();  
            }  
        }else {  
            mWifiList = results;
//            //如果你發現大量重複的wifi，可以替換爲以下代碼
//            mWifiList = new ArrayList();  
//            for (ScanResult result : results) {
//                //過濾無效的wifi
//                if (result.SSID == null || result.SSID.length() == 0
//                        || result.capabilities.contains("[IBSS]")) {
//                    continue;
//                }
//                
//                //去重
//                boolean found = false;
//                for (ScanResult item : mWifiList) {
//                    if (item.SSID.equals(result.SSID)
//                            && item.capabilities.equals(result.capabilities)) {
//                        found = true;
//                        break;
//                    }
//                }
//                if (!found) {
//                    mWifiList.add(result);
//                }
//            }
        }
    }    
     
    // 得到網絡列表     
    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;    
    }   
     
    // 得到接入點的BSSID     
    public String getBSSID() {    
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();    
    }    


    // 添加一個網絡並連接     
    public void addNetwork(WifiConfiguration wcg) {    
     int wcgID = mWifiManager.addNetwork(wcg);    
     boolean b =  mWifiManager.enableNetwork(wcgID, true);    
    }    
     
    // 斷開指定ID的網絡     
    public void disconnectWifi(int netId) {    
        mWifiManager.disableNetwork(netId);    
        mWifiManager.disconnect();    
    }  
    
    public void removeWifi(int netId) {  
        disconnectWifi(netId);  
        mWifiManager.removeNetwork(netId);  
    }  
     
//然後是一個實際應用方法，只驗證過沒有密碼的情況：   
     
    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;    
    }    
        
    private WifiConfiguration IsExsits(String SSID)     
    {     
        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();     
           for (WifiConfiguration existingConfig : existingConfigs)      
           {     
             if (existingConfig.SSID.equals("\""+SSID+"\""))     
             {     
                 return existingConfig;     
             }     
           }     
        return null;      
    }   
    
    public static boolean isLocked(ScanResult result){
        if (result.capabilities.contains("WEP") || result.capabilities.contains("PSK")
                || result.capabilities.contains("EAP")){
            return true;
        }
        return false;
    }
}