Android 连接Wifi和创建Wifi热点的实例

package com.widget.hotspot; 
import android.os.Bundle; 
import android.app.Activity; 
import android.content.BroadcastReceiver; 
import android.content.Context; 
import android.content.Intent; 
import android.content.IntentFilter; 
import android.util.Log; 
import android.view.Menu; 
import android.view.View; 
import android.widget.Button; 
 
public class MainActivity extends Activity { 
 
  public static final String TAG = "MainActivity"; 
   
  private Button mBtn1, mBtn2; 
   
  private WifiAdmin mWifiAdmin; 
   
  private Context mContext = null; 
  @Override 
  protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
     
    mContext = this; 
     
    setContentView(R.layout.activity_main); 
     
    mBtn1 = (Button)findViewById(R.id.button1); 
    mBtn2 = (Button)findViewById(R.id.button2); 
    mBtn1.setText("点击连接Wifi"); 
    mBtn2.setText("点击创建Wifi热点"); 
    mBtn1.setOnClickListener(new Button.OnClickListener() { 
       
      @Override 
      public void onClick(View v) { 
        // TODO Auto-generated method stub 
 
        mWifiAdmin = new WifiAdmin(mContext) { 
           
          @Override 
          public void myUnregisterReceiver(BroadcastReceiver receiver) { 
            // TODO Auto-generated method stub 
            MainActivity.this.unregisterReceiver(receiver); 
          } 
           
          @Override 
          public Intent myRegisterReceiver(BroadcastReceiver receiver, 
              IntentFilter filter) { 
            // TODO Auto-generated method stub 
            MainActivity.this.registerReceiver(receiver, filter); 
            return null; 
          } 
           
          @Override 
          public void onNotifyWifiConnected() { 
            // TODO Auto-generated method stub 
            Log.v(TAG, "have connected success!"); 
            Log.v(TAG, "###############################"); 
          } 
           
          @Override 
          public void onNotifyWifiConnectFailed() { 
            // TODO Auto-generated method stub 
            Log.v(TAG, "have connected failed!"); 
            Log.v(TAG, "###############################"); 
          } 
        }; 
        mWifiAdmin.openWifi(); 
        mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA)); 
         
      } 
    }); 
     
    mBtn2.setOnClickListener(new Button.OnClickListener() { 
       
      @Override 
      public void onClick(View v) { 
        // TODO Auto-generated method stub 
         
        WifiApAdmin wifiAp = new WifiApAdmin(mContext); 
        wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123"); 
      } 
    }); 
     
  } 
 
  @Override 
  public boolean onCreateOptionsMenu(Menu menu) { 
    // Inflate the menu; this adds items to the action bar if it is present. 
    getMenuInflater().inflate(R.menu.activity_main, menu); 
    return true; 
  } 
 
   @Override 
    public void onResume() { 
      super.onResume(); 
       
      Log.d("Rssi", "Registered"); 
    } 
 
    @Override 
    public void onPause() { 
      super.onPause(); 
       
      Log.d("Rssi", "Unregistered"); 
    } 
   
} 

package com.widget.hotspot;  
import java.util.List; 
import java.util.Timer; 
import java.util.TimerTask; 
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.NetworkInfo.DetailedState; 
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 abstract class WifiAdmin { 
   
  private static final String TAG = "WifiAdmin"; 
   
  private WifiManager mWifiManager; 
  private WifiInfo mWifiInfo; 
  // 扫描出的网络连接列表 
  private List<ScanResult> mWifiList; 
  private List<WifiConfiguration> mWifiConfiguration; 
 
  private WifiLock mWifiLock; 
   
  private String mPasswd = ""; 
  private String mSSID = ""; 
   
  private Context mContext = null; 
 
  public WifiAdmin(Context context) { 
     
    mContext = context; 
     
    // 取得WifiManager对象 
    mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); 
    // 取得WifiInfo对象 
    mWifiInfo = mWifiManager.getConnectionInfo(); 
     
    Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress()); 
  } 
 
  // 打开WIFI 
  public void openWifi() { 
    if (!mWifiManager.isWifiEnabled()) { 
      mWifiManager.setWifiEnabled(true); 
    } 
  } 
 
  // 关闭WIFI 
  public void closeWifi() { 
    if (mWifiManager.isWifiEnabled()) { 
      mWifiManager.setWifiEnabled(false); 
    } 
  } 
 
  public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter); 
   
  public abstract void myUnregisterReceiver(BroadcastReceiver receiver); 
   
  public abstract void onNotifyWifiConnected(); 
   
  public abstract void onNotifyWifiConnectFailed(); 
   
  // 添加一个网络并连接 
  public void addNetwork(WifiConfiguration wcg) { 
     
    register(); 
     
    WifiApAdmin.closeWifiAp(mContext); 
     
    int wcgID = mWifiManager.addNetwork(wcg); 
    boolean b = mWifiManager.enableNetwork(wcgID, true); 
  } 
   
  public static final int TYPE_NO_PASSWD = 0x11; 
  public static final int TYPE_WEP = 0x12; 
  public static final int TYPE_WPA = 0x13; 
   
  public void addNetwork(String ssid, String passwd, int type) { 
    if (ssid == null || passwd == null || ssid.equals("")) { 
      Log.e(TAG, "addNetwork() ## nullpointer error!"); 
      return; 
    } 
     
    if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) { 
      Log.e(TAG, "addNetwork() ## unknown type = " + type); 
    } 
     
    stopTimer(); 
    unRegister(); 
     
    addNetwork(createWifiInfo(ssid, passwd, type)); 
  } 
 
  private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { 
 
    @Override 
    public void onReceive(Context context, Intent intent) { 
      // TODO Auto-generated method stub 
      if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) { 
        Log.d(TAG, "RSSI changed"); 
         
        //有可能是正在获取，或者已经获取了 
        Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION); 
         
        if (isWifiContected(mContext) == WIFI_CONNECTED) { 
          stopTimer(); 
          onNotifyWifiConnected(); 
          unRegister(); 
        } else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) { 
          stopTimer(); 
          closeWifi(); 
          onNotifyWifiConnectFailed(); 
          unRegister(); 
        } else if (isWifiContected(mContext) == WIFI_CONNECTING) { 
           
        } 
      } 
    } 
  }; 
   
  private final int STATE_REGISTRING = 0x01; 
  private final int STATE_REGISTERED = 0x02; 
  private final int STATE_UNREGISTERING = 0x03; 
  private final int STATE_UNREGISTERED = 0x04; 
   
  private int mHaveRegister = STATE_UNREGISTERED; 
  private synchronized void register() { 
    Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister); 
 
    if (mHaveRegister == STATE_REGISTRING  
        || mHaveRegister == STATE_REGISTERED) { 
      return ; 
    } 
     
    mHaveRegister = STATE_REGISTRING; 
    myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION)); 
    mHaveRegister = STATE_REGISTERED; 
     
    startTimer(); 
  } 
   
  private synchronized void unRegister() { 
    Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister); 
     
    if (mHaveRegister == STATE_UNREGISTERED  
        || mHaveRegister == STATE_UNREGISTERING) { 
      return ; 
    } 
     
    mHaveRegister = STATE_UNREGISTERING; 
    myUnregisterReceiver(mBroadcastReceiver); 
    mHaveRegister = STATE_UNREGISTERED; 
  } 
   
  private Timer mTimer = null; 
  private void startTimer() { 
    if (mTimer != null) { 
      stopTimer(); 
    } 
     
    mTimer = new Timer(true); 
//   mTimer.schedule(mTimerTask, 0, 20 * 1000);// 20s 
    mTimer.schedule(mTimerTask, 30 * 1000); 
  } 
   
  private TimerTask mTimerTask = new TimerTask() { 
     
    @Override 
    public void run() { 
      // TODO Auto-generated method stub 
      Log.e(TAG, "timer out!"); 
      onNotifyWifiConnectFailed(); 
      unRegister(); 
    } 
  }; 
   
  private void stopTimer() { 
    if (mTimer != null) { 
      mTimer.cancel(); 
      mTimer = null; 
    } 
  } 
   
  @Override 
  protected void finalize() { 
    try { 
      super.finalize(); 
      unRegister(); 
    } catch (Throwable e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } 
  } 
   
  public WifiConfiguration createWifiInfo(String SSID, String password, int type) { 
     
    Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + 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); 
    } 
     
    // 分为三种情况：1没有密码2用wep加密3用wpa加密 
    if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS 
      config.wepKeys[0] = ""; 
      config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE); 
      config.wepTxKeyIndex = 0; 
       
    } else if (type == TYPE_WEP) { // 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; 
    } else if (type == TYPE_WPA) {  // 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; 
  } 
   
  public static final int WIFI_CONNECTED = 0x01; 
  public static final int WIFI_CONNECT_FAILED = 0x02; 
  public static final int WIFI_CONNECTING = 0x03; 
  /** 
   * 判断wifi是否连接成功,不是network 
   * 
   * @param context 
   * @return 
   */ 
  public int isWifiContected(Context context) { 
    ConnectivityManager connectivityManager = (ConnectivityManager) context 
        .getSystemService(Context.CONNECTIVITY_SERVICE); 
    NetworkInfo wifiNetworkInfo = connectivityManager 
        .getNetworkInfo(ConnectivityManager.TYPE_WIFI); 
     
    Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting()); 
    Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState()); 
    if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR 
        || wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) { 
      return WIFI_CONNECTING; 
    } else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) { 
      return WIFI_CONNECTED; 
    } else { 
      Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState()); 
      return WIFI_CONNECT_FAILED; 
    } 
  } 
   
  private WifiConfiguration IsExsits(String SSID) { 
    List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks(); 
    for (WifiConfiguration existingConfig : existingConfigs) { 
      if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) { 
        return existingConfig; 
      } 
    } 
    return null; 
  } 
   
 
 
  // 断开指定ID的网络 
  public void disconnectWifi(int netId) { 
    mWifiManager.disableNetwork(netId); 
    mWifiManager.disconnect(); 
  } 
   
  // 检查当前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(); 
  } 
} 

package com.widget.hotspot; 
 
import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.util.Timer; 
import java.util.TimerTask; 
 
import android.content.Context; 
import android.net.wifi.WifiConfiguration; 
import android.net.wifi.WifiManager; 
import android.util.Log; 
 
/** 
 * 创建热点 
 * 
 */ 
public class WifiApAdmin { 
  public static final String TAG = "WifiApAdmin"; 
   
  public static void closeWifiAp(Context context) { 
    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
    closeWifiAp(wifiManager); 
  } 
   
  private WifiManager mWifiManager = null; 
   
  private Context mContext = null; 
  public WifiApAdmin(Context context) { 
    mContext = context; 
     
    mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);  
     
    closeWifiAp(mWifiManager); 
  } 
   
  private String mSSID = ""; 
  private String mPasswd = ""; 
  public void startWifiAp(String ssid, String passwd) { 
    mSSID = ssid; 
    mPasswd = passwd; 
     
    if (mWifiManager.isWifiEnabled()) { 
      mWifiManager.setWifiEnabled(false); 
    }  
     
    stratWifiAp(); 
     
    MyTimerCheck timerCheck = new MyTimerCheck() { 
       
      @Override 
      public void doTimerCheckWork() { 
        // TODO Auto-generated method stub 
         
        if (isWifiApEnabled(mWifiManager)) { 
          Log.v(TAG, "Wifi enabled success!"); 
          this.exit(); 
        } else { 
          Log.v(TAG, "Wifi enabled failed!"); 
        } 
      } 
 
      @Override 
      public void doTimeOutWork() { 
        // TODO Auto-generated method stub 
        this.exit(); 
      } 
    }; 
    timerCheck.start(15, 1000); 
     
  } 
 
  public void stratWifiAp() { 
    Method method1 = null; 
    try { 
      method1 = mWifiManager.getClass().getMethod("setWifiApEnabled", 
          WifiConfiguration.class, boolean.class); 
      WifiConfiguration netConfig = new WifiConfiguration(); 
 
      netConfig.SSID = mSSID; 
      netConfig.preSharedKey = mPasswd; 
 
      netConfig.allowedAuthAlgorithms 
          .set(WifiConfiguration.AuthAlgorithm.OPEN); 
      netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN); 
      netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA); 
      netConfig.allowedKeyManagement 
          .set(WifiConfiguration.KeyMgmt.WPA_PSK); 
      netConfig.allowedPairwiseCiphers 
          .set(WifiConfiguration.PairwiseCipher.CCMP); 
      netConfig.allowedPairwiseCiphers 
          .set(WifiConfiguration.PairwiseCipher.TKIP); 
      netConfig.allowedGroupCiphers 
          .set(WifiConfiguration.GroupCipher.CCMP); 
      netConfig.allowedGroupCiphers 
          .set(WifiConfiguration.GroupCipher.TKIP); 
 
      method1.invoke(mWifiManager, netConfig, true); 
 
    } catch (IllegalArgumentException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } catch (IllegalAccessException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } catch (InvocationTargetException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } catch (SecurityException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } catch (NoSuchMethodException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } 
  } 
 
  private static void closeWifiAp(WifiManager wifiManager) { 
    if (isWifiApEnabled(wifiManager)) { 
      try { 
        Method method = wifiManager.getClass().getMethod("getWifiApConfiguration"); 
        method.setAccessible(true); 
 
        WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager); 
 
        Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class); 
        method2.invoke(wifiManager, config, false); 
      } catch (NoSuchMethodException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
      } catch (IllegalArgumentException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
      } catch (IllegalAccessException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
      } catch (InvocationTargetException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
      } 
    } 
  } 
 
  private static boolean isWifiApEnabled(WifiManager wifiManager) { 
    try { 
      Method method = wifiManager.getClass().getMethod("isWifiApEnabled"); 
      method.setAccessible(true); 
      return (Boolean) method.invoke(wifiManager); 
 
    } catch (NoSuchMethodException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
 
    return false; 
  } 
 
} 

package com.widget.hotspot; 
public abstract class MyTimerCheck { 
  private int mCount = 0; 
  private int mTimeOutCount = 1; 
  private int mSleepTime = 1000; // 1s 
  private boolean mExitFlag = false; 
  private Thread mThread = null; 
   
  /** 
   * Do not process UI work in this. 
   */ 
  public abstract void doTimerCheckWork(); 
   
  public abstract void doTimeOutWork(); 
   
  public MyTimerCheck() { 
    mThread = new Thread(new Runnable() { 
       
      @Override 
      public void run() { 
        // TODO Auto-generated method stub 
        while (!mExitFlag) { 
          mCount++; 
          if (mCount < mTimeOutCount) { 
            doTimerCheckWork(); 
            try { 
              mThread.sleep(mSleepTime); 
            } catch (InterruptedException e) { 
              // TODO Auto-generated catch block 
              e.printStackTrace(); 
              exit(); 
            } 
          } else { 
            doTimeOutWork(); 
          } 
        } 
      } 
    }); 
  } 
   
  /** 
   * start 
   * @param times How many times will check? 
   * @param sleepTime ms, Every check sleep time. 
   */ 
  public void start(int timeOutCount, int sleepTime) { 
    mTimeOutCount = timeOutCount; 
    mSleepTime = sleepTime; 
     
    mThread.start(); 
  } 
   
  public void exit() { 
    mExitFlag = true; 
  } 
   
}