Android 蓝牙通信及WiFi开发

柔光的暖阳◎ 2022-09-29 14:51 531阅读 0赞

在我们正常的Android蓝牙功能开发步骤中，一般要经过系统权限和蓝牙开关状态监测、设备扫描、设备连接、蓝牙数据通信这几个过程。
在Android 4.3系统之后，我们可以使用蓝牙4.0（低功耗蓝牙），它最主要的特点是低功耗，普及率高。现在所说的蓝牙设备，大部分都是在说4.0设备，ble也特指4.0设备。 在4.0之前重要的版本有2.1版本-基本速率／增强数据率(BR/EDR)和3.0 高速蓝牙版本，这些统称为经典蓝牙。

如果想让支持低功耗蓝牙的设备使用蓝牙4.0，我们可以通过如下代码去监测

  1. // AndroidManifest.xml
  2. <uses-feature android:name="android.hardware.bluetooth_le" android:required="false"/>
  4. if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
  5.     Toast.makeText(this, R.string.ble_not_supported, Toast.LENGTH_SHORT).show();
  6.     finish();
  7. }

权限监测

首先我们必须要给予应用相应的蓝牙权限。

  1. //需要此权限来执行任何蓝牙通信，如请求一个连接、接受一个连接和传输数据。
  2.     <uses-permission android:name="android.permission.BLUETOOTH"/>
  3.     //如果你想让你的应用启动设备发现或操纵蓝牙设置，必须申报bluetooth_admin许可
  4.     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

然后在程序启动时监测当前设备是否已经打开蓝牙，若没打开则跳转到系统蓝牙功能开关界面选择开启蓝牙

  1. // If BT is not on, request that it be enabled.
  2.         // setupChat() will then be called during onActivityResult
  3.         if (!mBluetoothAdapter.isEnabled()) {
  4.             Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  5.             startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
  6.             // Otherwise, setup the chat session
  7.         } else if (mChatService == null) {
  8.             setupChat();
  9.         }

在onActivityResult中捕获

  1. public void onActivityResult(int requestCode, int resultCode, Intent data) {
  2.         switch (requestCode) {
  3.             case REQUEST_ENABLE_BT:
  4.                 // When the request to enable Bluetooth returns
  5.                 if (resultCode == Activity.RESULT_OK) {
  6.                     // Bluetooth is now enabled, so set up a chat session
  7.                     setupChat();
  8.                 } else {
  9.                     // User did not enable Bluetooth or an error occurred
  10.                     Log.d(TAG, "BT not enabled");
  11.                     Toast.makeText(getActivity(), R.string.bt_not_enabled_leaving,
  12.                             Toast.LENGTH_SHORT).show();
  13.                     getActivity().finish();
  14.                 }
  15.         }
  16.     }

设备扫描

我们只需要调用BluetoothAdapter的startDiscovery（）方法，便开始搜索附近的其他蓝牙设备，

  1. /**
  2.      * Start device discover with the BluetoothAdapter
  3.      */
  4.     private void doDiscovery() {
  5.         // If we're already discovering, stop it
  6.         if (mBtAdapter.isDiscovering()) {
  7.             mBtAdapter.cancelDiscovery();
  8.         }
  10.         // Request discover from BluetoothAdapter
  11.         mBtAdapter.startDiscovery();
  12.     }

之后，如果搜索到一个蓝牙设备，系统就是发出一个广播，我们可以对它进行接收并且进行相应的处理：

  1. // Register for broadcasts when a device is discovered
  2.         IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
  3.         this.registerReceiver(mReceiver, filter);
  5.         // Register for broadcasts when discovery has finished
  6.         filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
  7.         this.registerReceiver(mReceiver, filter);
  9. /**
  10.      * The BroadcastReceiver that listens for discovered devices and changes the title when
  11.      * discovery is finished
  12.      */
  13.     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
  14.         @Override
  15.         public void onReceive(Context context, Intent intent) {
  16.             String action = intent.getAction();
  18.             // When discovery finds a device
  19.             if (BluetoothDevice.ACTION_FOUND.equals(action)) {
  20.                 // Get the BluetoothDevice object from the Intent
  21.                 BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  22.                 // If it's already paired, skip it, because it's been listed already
  23.                 if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
  24.                     mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
  25.                 }
  26.                 // When discovery is finished, change the Activity title
  27.             } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
  28.                 setProgressBarIndeterminateVisibility(false);
  29.                 setTitle(R.string.select_device);
  30.                 if (mNewDevicesArrayAdapter.getCount() == 0) {
  31.                     //do something here after finished discovery
  32.                 }
  33.             }
  34.         }
  35.     };

连接

在搜索到的其它设备里选择一个需要连接通信的设备，传入设备的地址，调用getRemoteDevice方法去获得一个BluetoothDevice 实例，然后开辟一个子线程用于建立连接，

  1. private void connectDevice(Intent data, boolean secure) {
  2.         // Get the device MAC address
  3.         String address = data.getExtras()
  4.                 .getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
  5.         // Get the BluetoothDevice object
  6.         BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
  7.         // Attempt to connect to the device
  8.         mChatService.connect(device, secure);
  9.     }
  11. /**
  12.      * Start the ConnectThread to initiate a connection to a remote device.
  13.      *
  14.      * @param device The BluetoothDevice to connect
  15.      * @param secure Socket Security type - Secure (true) , Insecure (false)
  16.      */
  17.     public synchronized void connect(BluetoothDevice device, boolean secure) {
  18.         Log.d(TAG, "connect to: " + device);
  20.         // Cancel any thread attempting to make a connection
  21.         if (mState == STATE_CONNECTING) {
  22.             if (mConnectThread != null) {
  23.                 mConnectThread.cancel();
  24.                 mConnectThread = null;
  25.             }
  26.         }
  28.         // Cancel any thread currently running a connection
  29.         if (mConnectedThread != null) {
  30.             mConnectedThread.cancel();
  31.             mConnectedThread = null;
  32.         }
  34.         // Start the thread to connect with the given device
  35.         mConnectThread = new ConnectThread(device, secure);
  36.         mConnectThread.start();
  37.         // Update UI 
  38.     }

连接线程：此处调用了device.createRfcommSocketToServiceRecord方法去创建一个用于通信的socket，参数是UUID，是一个通用标识符。

  1. private class ConnectThread extends Thread {
  3.         private final BluetoothSocket mmSocket;
  4.         private final BluetoothDevice mmDevice;
  5.         private String mSocketType;
  7.         public ConnectThread(BluetoothDevice device, boolean secure) {
  8.             mmDevice = device;
  9.             BluetoothSocket tmp = null;
  10.             mSocketType = secure ? "Secure" : "Insecure";
  12.             // Get a BluetoothSocket for a connection with the
  13.             // given BluetoothDevice
  14.             try {
  15.                 if (secure) {
  16.                     tmp = device.createRfcommSocketToServiceRecord(
  17.                             MY_UUID_SECURE);
  18.                 } else {
  19.                     tmp = device.createInsecureRfcommSocketToServiceRecord(
  20.                             MY_UUID_INSECURE);
  21.                 }
  22.             } catch (IOException e) {
  23.                 Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
  24.             }
  25.             mmSocket = tmp;
  26.             mState = STATE_CONNECTING;
  27.         }
  29.         public void run() {
  30.             Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);
  31.             setName("ConnectThread" + mSocketType);
  33.             // Always cancel discovery because it will slow down a connection
  34.             mAdapter.cancelDiscovery();
  36.             // Make a connection to the BluetoothSocket
  37.             try {
  38.                 // This is a blocking call and will only return on a
  39.                 // successful connection or an exception
  40.                 mmSocket.connect();
  41.             } catch (IOException e) {
  42.                 // Close the socket
  43.                 try {
  44.                     mmSocket.close();
  45.                 } catch (IOException e2) {
  46.                     Log.e(TAG, "unable to close() " + mSocketType +
  47.                             " socket during connection failure", e2);
  48.                 }
  49.                 connectionFailed();
  50.                 return;
  51.             }
  53.             // Reset the ConnectThread because we're done
  54.             synchronized (BluetoothChatService.this) {
  55.                 mConnectThread = null;
  56.             }
  58.             // Start the connected thread
  59.             connected(mmSocket, mmDevice, mSocketType);
  60.         }
  62.         public void cancel() {
  63.             try {
  64.                 mmSocket.close();
  65.             } catch (IOException e) {
  66.                 Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);
  67.             }
  68.         }
  69.     }

设备连接完成后，要取消连接线程，防止造成资源的浪费，然后创建通信线程，维持输入输出流的接收和发送。

  1. public synchronized void connected(BluetoothSocket socket, BluetoothDevice
  2.             device, final String socketType) {
  3.         Log.d(TAG, "connected, Socket Type:" + socketType);
  5.         // Cancel the thread that completed the connection
  6.         if (mConnectThread != null) {
  7.             mConnectThread.cancel();
  8.             mConnectThread = null;
  9.         }
  12.         // Start the thread to manage the connection and perform transmissions
  13.         mConnectedThread = new ConnectedThread(socket, socketType);
  14.         mConnectedThread.start();
  16.         // Send the name of the connected device back to the UI Activity
  17.         Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);
  18.         Bundle bundle = new Bundle();
  19.         bundle.putString(Constants.DEVICE_NAME, device.getName());
  20.         msg.setData(bundle);
  21.         mHandler.sendMessage(msg);
  22.         // Update UI title
  23.         updateUserInterfaceTitle();
  24.     }

消息传输线程：run方法是一个while循环，当处于连接状态时，会一直从输入流中获取数据，并将获取到的字节数据通过handle机制传输到主线程并显示。在需要发送数据时，只要调用write方法即可。

  1. /**
  2.      * This thread runs during a connection with a remote device.
  3.      * It handles all incoming and outgoing transmissions.
  4.      */
  5.     private class ConnectedThread extends Thread {
  7.         private final BluetoothSocket mmSocket;
  8.         private final InputStream mmInStream;
  9.         private final OutputStream mmOutStream;
  11.         public ConnectedThread(BluetoothSocket socket, String socketType) {
  12.             Log.d(TAG, "create ConnectedThread: " + socketType);
  13.             mmSocket = socket;
  14.             InputStream tmpIn = null;
  15.             OutputStream tmpOut = null;
  17.             // Get the BluetoothSocket input and output streams
  18.             try {
  19.                 tmpIn = socket.getInputStream();
  20.                 tmpOut = socket.getOutputStream();
  21.             } catch (IOException e) {
  22.                 Log.e(TAG, "temp sockets not created", e);
  23.             }
  25.             mmInStream = tmpIn;
  26.             mmOutStream = tmpOut;
  27.             mState = STATE_CONNECTED;
  28.         }
  30.         public void run() {
  31.             Log.i(TAG, "BEGIN mConnectedThread");
  32.             byte[] buffer = new byte[1024];
  33.             int bytes;
  35.             // Keep listening to the InputStream while connected
  36.             while (mState == STATE_CONNECTED) {
  37.                 try {
  38.                     // Read from the InputStream
  39.                     bytes = mmInStream.read(buffer);
  41.                     // Send the obtained bytes to the UI Activity
  42.                     mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, -1, buffer)
  43.                             .sendToTarget();
  44.                 } catch (IOException e) {
  45.                     Log.e(TAG, "disconnected", e);
  46.                     connectionLost();
  47.                     break;
  48.                 }
  49.             }
  50.         }
  52.         /**
  53.          * Write to the connected OutStream.
  54.          *
  55.          * @param buffer The bytes to write
  56.          */
  57.         public void write(byte[] buffer) {
  58.             try {
  59.                 mmOutStream.write(buffer);
  61.                 // Share the sent message back to the UI Activity
  62.                 mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)
  63.                         .sendToTarget();
  64.             } catch (IOException e) {
  65.                 Log.e(TAG, "Exception during write", e);
  66.             }
  67.         }
  69.         public void cancel() {
  70.             try {
  71.                 mmSocket.close();
  72.             } catch (IOException e) {
  73.                 Log.e(TAG, "close() of connect socket failed", e);
  74.             }
  75.         }
  76.     }

至此，通过蓝牙实现数据传输的过程基本建立完毕。此处是针对普通蓝牙的通信方式，若使用低功耗蓝牙，可详见Google的官方sample：
android-BuletoothLeGatt

AndroidWiFi学习

一、WiFi相关知识

Android WiFi开发需掌握基本的操作，包括扫描附近WiFi、控制WiFi的开闭、发射WiFi热点等。
在Android的sdk中， WiFi相关的操作类都在Android.net.wifi包里面。接下来就跟随官方Guide来学习Android中WiFi的基本操作。
Google开发者中国网站api

其中主要的类有ScanResult ，wifiConfiguration， WifiInfo ，WifiManager。

ScanResult

主要用来描述已经检测出的接入点，包括接入点的地址，接入点的名称，身份认证，频率，信号强度等信息。
打开这个类，我们可以看到以下几个信息

  • BSSID 接入点的地址，这里主要是指小范围几个无线设备相连接所获取的地址，比如说两台笔记本通过无线网卡进行连接，双方的无线网卡分配的地址。
  • SSID 网络的名字，当我们搜索一个网络时，就是靠这个来区分每个不同的网络接入点。
  • Capabilities 网络接入的性能，这里主要是来判断网络的加密方式等。
  • Frequency 频率，每一个频道交互的MHz 数。
  • Level 等级，主要来判断网络连接的优先数。

wifiConfiguration

包括以下六个子类：

  • WifiConfiguration.AuthAlgorthm 用来判断加密方法。
  • WifiConfiguration.GroupCipher 获取使用GroupCipher 的方法来进行加密。
  • WifiConfiguration.KeyMgmt 获取使用KeyMgmt 进行。
  • WifiConfiguration.PairwiseCipher 获取使用WPA 方式的加密。
  • WifiConfiguration.Protocol 获取使用哪一种协议进行加密。
  • wifiConfiguration.Status 获取当前网络的状态。

WifiInfo

在我们的wifi 已经连通了以后，可以通过这个类获得一些已经连通的wifi 连接的信息获取当前链接的信息.

  • getBSSID()： 获取BSSID
  • getDetailedStateOf() ： 获取客户端的连通性
  • getHiddenSSID() ： 获得SSID 是否被隐藏
  • getIpAddress() ： 获取IP 地址
  • getLinkSpeed() ： 获得连接的速度
  • getMacAddress() ： 获得Mac 地址
  • getRssi() 获得802.11n ： 网络的信号
  • getSSID() ： 获得SSID
  • getSupplicanState() ： 返回具体客户端状态的信息

wifiManager

这个类提供了WiFi连接的管理功能，我们可以调用Context.getSystemService(Context.WIFI_SERVICE)来获取，常用方法如下：

  • addNetwork(WifiConfiguration config) 通过获取到的网络的链接状态信息，来添加网络
  • calculateSignalLevel(int rssi , int numLevels) 计算信号的等级
  • compareSignalLevel(int rssiA, int rssiB) 对比连接A 和连接B
  • createWifiLock(int lockType, String tag) 创建一个wifi 锁，锁定当前的wifi 连接
  • disableNetwork(int netId) 让一个网络连接失效
  • disconnect() 断开连接
  • enableNetwork(int netId, Boolean disableOthers) 连接一个连接
  • getConfiguredNetworks() 获取网络连接的状态
  • getConnectionInfo() 获取当前连接的信息
  • getDhcpInfo() 获取DHCP 的信息
  • getScanResulats() 获取扫描测试的结果
  • getWifiState() 获取一个wifi 接入点是否有效
  • isWifiEnabled() 判断一个wifi 连接是否有效
  • pingSupplicant() ping 一个连接，判断是否能连通
  • ressociate() 即便连接没有准备好，也要连通
  • reconnect() 如果连接准备好了，连通
  • removeNetwork() 移除某一个网络
  • saveConfiguration() 保留一个配置信息
  • setWifiEnabled() 让一个连接有效
  • startScan() 开始扫描
  • updateNetwork(WifiConfiguration config) 更新一个网络连接的信息
    详细api见官方api

二、WiFi功能使用

配置WiFi权限

  1. <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
  2. <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE"/>

WiFi管理类

这是从网上整理的一个WiFi相关的工具类，WiFi开发的很多场景需要用到的方法都在里面实现了。

  1. /**
  2.  * WIFI管理类
  3.  * @author ZHF
  4.  *
  5.  */
  6. public class WifiAdmin {
  8.     private static  WifiAdmin wifiAdmin = null;
  10.     private List<WifiConfiguration> mWifiConfiguration; //无线网络配置信息类集合(网络连接列表)
  11.     private List<ScanResult> mWifiList; //检测到接入点信息类 集合
  13.     //描述任何Wifi连接状态
  14.     private WifiInfo mWifiInfo;
  16.     WifiManager.WifiLock mWifilock; //能够阻止wifi进入睡眠状态，使wifi一直处于活跃状态
  17.     public WifiManager mWifiManager;
  19.     /**
  20.      * 获取该类的实例（懒汉）
  21.      * @param context
  22.      * @return
  23.      */
  24.     public static WifiAdmin getInstance(Context context) {
  25.         if(wifiAdmin == null) {
  26.             wifiAdmin = new WifiAdmin(context);
  27.             return wifiAdmin;
  28.         }
  29.         return null;
  30.     }
  31.     private WifiAdmin(Context context) {
  32.         //获取系统Wifi服务   WIFI_SERVICE
  33.         this.mWifiManager = (WifiManager) context.getSystemService("wifi");
  34.         //获取连接信息
  35.         this.mWifiInfo = this.mWifiManager.getConnectionInfo();
  36.     }
  38.     /**
  39.      * 是否存在网络信息
  40.      * @param str  热点名称
  41.      * @return
  42.      */
  43.     private WifiConfiguration isExsits(String str) {
  44.         Iterator localIterator = this.mWifiManager.getConfiguredNetworks().iterator();
  45.         WifiConfiguration localWifiConfiguration;
  46.         do {
  47.             if(!localIterator.hasNext()) return null;
  48.             localWifiConfiguration = (WifiConfiguration) localIterator.next();
  49.         }while(!localWifiConfiguration.SSID.equals("\"" + str + "\""));
  50.         return localWifiConfiguration;
  51.     }
  53.     /**锁定WifiLock，当下载大文件时需要锁定 **/
  54.     public void AcquireWifiLock() {
  55.         this.mWifilock.acquire();
  56.     }
  57.     /**创建一个WifiLock**/
  58.     public void CreateWifiLock() {
  59.         this.mWifilock = this.mWifiManager.createWifiLock("Test");
  60.     }
  61.     /**解锁WifiLock**/
  62.     public void ReleaseWifilock() {
  63.         if(mWifilock.isHeld()) { //判断时候锁定
  64.             mWifilock.acquire();
  65.         }
  66.     }
  69.     /**打开Wifi**/
  70.     public void OpenWifi() {
  71.         if(!this.mWifiManager.isWifiEnabled()){ //当前wifi不可用
  72.             this.mWifiManager.setWifiEnabled(true);
  73.         }
  74.     }
  75.     /**关闭Wifi**/
  76.     public void closeWifi() {
  77.         if(mWifiManager.isWifiEnabled()) {
  78.             mWifiManager.setWifiEnabled(false);
  79.         }
  80.     }
  81.     /**端口指定id的wifi**/
  82.     public void disconnectWifi(int paramInt) {
  83.         this.mWifiManager.disableNetwork(paramInt);
  84.     }
  86.     /**添加指定网络**/
  87.     public void addNetwork(WifiConfiguration paramWifiConfiguration) {
  88.         int i = mWifiManager.addNetwork(paramWifiConfiguration);
  89.         mWifiManager.enableNetwork(i, true);
  90.     }
  92.     /**
  93.      * 连接指定配置好的网络
  94.      * @param index 配置好网络的ID
  95.      */
  96.     public void connectConfiguration(int index) { 
  97.         // 索引大于配置好的网络索引返回  
  98.         if (index > mWifiConfiguration.size()) { 
  99.             return; 
  100.         } 
  101.         //连接配置好的指定ID的网络  
  102.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId, true); 
  103.     }
  105.     /**
  106.      * 根据wifi信息创建或关闭一个热点
  107.      * @param paramWifiConfiguration
  108.      * @param paramBoolean 关闭标志
  109.      */
  110.     public void createWifiAP(WifiConfiguration paramWifiConfiguration,boolean paramBoolean) {
  111.         try {
  112.             Class localClass = this.mWifiManager.getClass();
  113.             Class[] arrayOfClass = new Class[2];
  114.             arrayOfClass[0] = WifiConfiguration.class;
  115.             arrayOfClass[1] = Boolean.TYPE;
  116.             Method localMethod = localClass.getMethod("setWifiApEnabled",arrayOfClass);
  117.             WifiManager localWifiManager = this.mWifiManager;
  118.             Object[] arrayOfObject = new Object[2];
  119.             arrayOfObject[0] = paramWifiConfiguration;
  120.             arrayOfObject[1] = Boolean.valueOf(paramBoolean);
  121.             localMethod.invoke(localWifiManager, arrayOfObject);
  122.             return;
  123.         } catch (Exception e) {
  124.             e.printStackTrace();
  125.         }
  126.     }
  127.     /**
  128.      * 创建一个wifi信息
  129.      * @param ssid 名称
  130.      * @param passawrd 密码
  131.      * @param paramInt 有3个参数，1是无密码，2是简单密码，3是wap加密
  132.      * @param type 是"ap"还是"wifi"
  133.      * @return
  134.      */
  135.     public WifiConfiguration createWifiInfo(String ssid, String passawrd,int paramInt, String type) {
  136.         //配置网络信息类
  137.         WifiConfiguration localWifiConfiguration1 = new WifiConfiguration();
  138.         //设置配置网络属性
  139.         localWifiConfiguration1.allowedAuthAlgorithms.clear();
  140.         localWifiConfiguration1.allowedGroupCiphers.clear();
  141.         localWifiConfiguration1.allowedKeyManagement.clear();
  142.         localWifiConfiguration1.allowedPairwiseCiphers.clear();
  143.         localWifiConfiguration1.allowedProtocols.clear();
  145.         if(type.equals("wt")) { //wifi连接
  146.             localWifiConfiguration1.SSID = ("\"" + ssid + "\"");
  147.             WifiConfiguration localWifiConfiguration2 = isExsits(ssid);
  148.             if(localWifiConfiguration2 != null) {
  149.                 mWifiManager.removeNetwork(localWifiConfiguration2.networkId); //从列表中删除指定的网络配置网络
  150.             }
  151.             if(paramInt == 1) { //没有密码
  152.                 localWifiConfiguration1.wepKeys[0] = "";
  153.                 localWifiConfiguration1.allowedKeyManagement.set(0);
  154.                 localWifiConfiguration1.wepTxKeyIndex = 0;
  155.             } else if(paramInt == 2) { //简单密码
  156.                 localWifiConfiguration1.hiddenSSID = true;
  157.                 localWifiConfiguration1.wepKeys[0] = ("\"" + passawrd + "\"");
  158.             } else { //wap加密
  159.                 localWifiConfiguration1.preSharedKey = ("\"" + passawrd + "\"");
  160.                 localWifiConfiguration1.hiddenSSID = true;
  161.                 localWifiConfiguration1.allowedAuthAlgorithms.set(0);
  162.                 localWifiConfiguration1.allowedGroupCiphers.set(2);
  163.                 localWifiConfiguration1.allowedKeyManagement.set(1);
  164.                 localWifiConfiguration1.allowedPairwiseCiphers.set(1);
  165.                 localWifiConfiguration1.allowedGroupCiphers.set(3);
  166.                 localWifiConfiguration1.allowedPairwiseCiphers.set(2);
  167.             }
  168.         }else {
  169.    //"ap" wifi热点
  170.             localWifiConfiguration1.SSID = ssid;
  171.             localWifiConfiguration1.allowedAuthAlgorithms.set(1);
  172.             localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  173.             localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  174.             localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
  175.             localWifiConfiguration1.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
  176.             localWifiConfiguration1.allowedKeyManagement.set(0);
  177.             localWifiConfiguration1.wepTxKeyIndex = 0;
  178.             if (paramInt == 1) {  //没有密码
  179.                 localWifiConfiguration1.wepKeys[0] = "";
  180.                 localWifiConfiguration1.allowedKeyManagement.set(0);
  181.                 localWifiConfiguration1.wepTxKeyIndex = 0;
  182.             } else if (paramInt == 2) { //简单密码
  183.                 localWifiConfiguration1.hiddenSSID = true;//网络上不广播ssid
  184.                 localWifiConfiguration1.wepKeys[0] = passawrd;
  185.             } else if (paramInt == 3) {
  186.    //wap加密
  187.                 localWifiConfiguration1.preSharedKey = passawrd;
  188.                 localWifiConfiguration1.allowedAuthAlgorithms.set(0);
  189.                 localWifiConfiguration1.allowedProtocols.set(1);
  190.                 localWifiConfiguration1.allowedProtocols.set(0);
  191.                 localWifiConfiguration1.allowedKeyManagement.set(1);
  192.                 localWifiConfiguration1.allowedPairwiseCiphers.set(2);
  193.                 localWifiConfiguration1.allowedPairwiseCiphers.set(1);
  194.             }
  195.         }
  196.         return localWifiConfiguration1;
  197.     }
  199.     /**获取热点名**/
  200.     public String getApSSID() {
  201.         try {
  202.             Method localMethod = this.mWifiManager.getClass().getDeclaredMethod("getWifiApConfiguration", new Class[0]);
  203.             if (localMethod == null) return null;
  204.             Object localObject1 = localMethod.invoke(this.mWifiManager,new Object[0]);
  205.             if (localObject1 == null) return null;
  206.             WifiConfiguration localWifiConfiguration = (WifiConfiguration) localObject1;
  207.             if (localWifiConfiguration.SSID != null) return localWifiConfiguration.SSID;
  208.             Field localField1 = WifiConfiguration.class .getDeclaredField("mWifiApProfile");
  209.             if (localField1 == null) return null;
  210.             localField1.setAccessible(true);
  211.             Object localObject2 = localField1.get(localWifiConfiguration);
  212.             localField1.setAccessible(false);
  213.             if (localObject2 == null)  return null;
  214.             Field localField2 = localObject2.getClass().getDeclaredField("SSID");
  215.             localField2.setAccessible(true);
  216.             Object localObject3 = localField2.get(localObject2);
  217.             if (localObject3 == null) return null;
  218.             localField2.setAccessible(false);
  219.             String str = (String) localObject3;
  220.             return str;
  221.         } catch (Exception localException) {
  222.         }
  223.         return null;
  224.     }
  226.     /**获取wifi名**/
  227.     public String getBSSID() {
  228.         if (this.mWifiInfo == null)
  229.             return "NULL";
  230.         return this.mWifiInfo.getBSSID();
  231.     }
  233.    /**得到配置好的网络 **/
  234.     public List<WifiConfiguration> getConfiguration() {
  235.         return this.mWifiConfiguration;
  236.     }
  238.     /**获取ip地址**/
  239.     public int getIPAddress() {
  240.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
  241.     }
  242.     /**获取物理地址(Mac)**/
  243.     public String getMacAddress() {
  244.          return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
  245.     }   
  247.     /**获取网络id**/
  248.     public int getNetworkId() {
  249.          return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
  250.     }
  251.     /**获取热点创建状态**/
  252.     public int getWifiApState() {
  253.         try {
  254.             int i = ((Integer) this.mWifiManager.getClass()
  255.                     .getMethod("getWifiApState", new Class[0])
  256.                     .invoke(this.mWifiManager, new Object[0])).intValue();
  257.             return i;
  258.         } catch (Exception localException) {
  259.         }
  260.         return 4;   //未知wifi网卡状态
  261.     }
  262.     /**获取wifi连接信息**/
  263.     public WifiInfo getWifiInfo() {
  264.         return this.mWifiManager.getConnectionInfo();
  265.     }
  266.     /** 得到网络列表**/
  267.     public List<ScanResult> getWifiList() {
  268.         return this.mWifiList;
  269.     }
  271.     /**查看扫描结果**/
  272.     public StringBuilder lookUpScan() {
  273.         StringBuilder localStringBuilder = new StringBuilder();
  274.         for (int i = 0; i < mWifiList.size(); i++)
  275.         {
  276.             localStringBuilder.append("Index_"+new Integer(i + 1).toString() + ":");
  277.             //将ScanResult信息转换成一个字符串包
  278.             //其中把包括：BSSID、SSID、capabilities、frequency、level
  279.             localStringBuilder.append((mWifiList.get(i)).toString());
  280.             localStringBuilder.append("\n");
  281.         }
  282.         return localStringBuilder;
  283.     }
  285.     /** 设置wifi搜索结果 **/
  286.     public void setWifiList() {
  287.         this.mWifiList = this.mWifiManager.getScanResults();
  288.     }
  289.     /**开始搜索wifi**/
  290.     public void startScan() {
  291.         this.mWifiManager.startScan();
  292.     }
  293.     /**得到接入点的BSSID**/
  294.     public String GetBSSID() {
  295.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
  296.     }
  297. }

WiFi热点的创建

创建WiFi热点需要先获取到wifi的服务，再配置热点名称、密码等等，然后再通过反射调用setWifiApEnabled方法来创建热点。因为wifi和热点不能同时打开，所以打开热点的时候需要调用wifiManager.setWifiEnabled(false); 关闭wifi

  1. public void stratWifiAp() {  
  2.         Method method1 = null;  
  3.         try {  
  4.             method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",  
  5.                     WifiConfiguration.class, boolean.class);  
  6.             WifiConfiguration netConfig = new WifiConfiguration();  
  8.             netConfig.SSID = mSSID;  
  9.             netConfig.preSharedKey = mPasswd;  
  11.             netConfig.allowedAuthAlgorithms  
  12.                     .set(WifiConfiguration.AuthAlgorithm.OPEN);  
  13.             netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);  
  14.             netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
  15.             netConfig.allowedKeyManagement  
  16.                     .set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  17.             netConfig.allowedPairwiseCiphers  
  18.                     .set(WifiConfiguration.PairwiseCipher.CCMP);  
  19.             netConfig.allowedPairwiseCiphers  
  20.                     .set(WifiConfiguration.PairwiseCipher.TKIP);  
  21.             netConfig.allowedGroupCiphers  
  22.                     .set(WifiConfiguration.GroupCipher.CCMP);  
  23.             netConfig.allowedGroupCiphers  
  24.                     .set(WifiConfiguration.GroupCipher.TKIP);  
  26.             method1.invoke(mWifiManager, netConfig, true);  
  28.         } catch (IllegalArgumentException e) {  
  29.             // TODO Auto-generated catch block  
  30.             e.printStackTrace();  
  31.         } catch (IllegalAccessException e) {  
  32.             // TODO Auto-generated catch block  
  33.             e.printStackTrace();  
  34.         } catch (InvocationTargetException e) {  
  35.             // TODO Auto-generated catch block  
  36.             e.printStackTrace();  
  37.         } catch (SecurityException e) {  
  38.             // TODO Auto-generated catch block  
  39.             e.printStackTrace();  
  40.         } catch (NoSuchMethodException e) {  
  41.             // TODO Auto-generated catch block  
  42.             e.printStackTrace();  
  43.         }  
  44.     }

参考文章：
Android开发之蓝牙通信
Android BulutoothChat
Android中WiFi开发总结

发表评论

表情：
评论列表 （有 0 条评论，531人围观）

还没有评论，来说两句吧...

相关阅读