Android 连接Wifi和创建Wifi热点的实例-编程学习网

本文实例讲述了连接Wifi和创建Wifi热点的方法。分享给大家供大家参考，具体如下：

android的热点功能不可见，用了反射的技术搞定之外。

Eclipse设置语言为utf-8才能查看中文注释

上代码：

MainActivity.java


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"); 
    } 
}

WifiAdmin.java


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; 
   
  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 + "\"") ) { 
        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(); 
  } 
}

WifiApAdmin.java


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; 
  } 
}

MyTimeCheck.java


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; 
   
  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(); 
          } 
        } 
      } 
    }); 
  } 
   
  public void start(int timeOutCount, int sleepTime) { 
    mTimeOutCount = timeOutCount; 
    mSleepTime = sleepTime; 
    mThread.start(); 
  } 
  public void exit() { 
    mExitFlag = true; 
  } 
}

您可能感兴趣的文章:Android获取当前已连接的wifi信号强度的方法android编程实现设置、打开wifi热点共享供他人连接的方法Android连接指定Wifi的方法实例代码android连接wifi时获取广播地址代码Android编程实现获取当前连接wifi名字的方法ubuntu用wifi连接android调试程序的步骤Android 判断是否连接成功了指定wifiAndroid编程判断是否连接网络的方法【WiFi及3G判断】通过WIFI（不用数据线）连接Android手机调试Android通过wifi连接手机(不需要root)Android编程实现wifi扫描及连接的方法

文章详情

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

软考中级精品资料免费领

相关文章

猜你喜欢

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

Android连接指定Wifi的方法实例代码

如何解决win7无法创建wifi热点的问题

Android的WIFI和以太网连接状态

android编程实现设置、打开wifi热点共享供他人连接的方法

Win10怎么创建Wifi热点？Win10系统笔记本设置WiFi共享的方法详解

Android编程实现获取当前连接wifi名字的方法

如何解决XP系统下160WIFI创建WiFi热点后手机无法正常上网的问题

数据库系统--基于MySQL的数据库和表的创建及Navicat 连接 MySQL操作（超详细/设计/实验/作业/练习）