首页 > 代码库 > Android 蓝牙操作详解

Android 蓝牙操作详解

2024-07-10 13:43:38   220人阅读

1.启用蓝牙并使设备处于可发现状态    


   1.1 在使用BluetoothAdapter类的实例进操作之前，应启用isEnable()方法检查设备是否启用了蓝牙适配器。
 
    // 使用意图提示用户启用蓝牙，并使设备处于可发现状态
     private void startBluetooth() {
          BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
           // 检测蓝牙是否开启
           if (!bt.isEnabled()) {
              Intent enableIntent = new Intent(
                        BluetoothAdapter. ACTION_REQUEST_ENABLE);
              startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
          }
     }
 1.2返回意图活动时，调用onActivityResult(),可以提取主设备名称和mac地址
 
 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
           if (requestCode == REQUEST_ENABLE_BT
                   && resultCode == Activity. RESULT_OK) {
              BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
              String address = bt.getAddress();
              String name = bt.getName();
              String toastText = name + " :" + address;
              Toast. makeText(this, toastText, Toast.LENGTH_LONG).show();
              discoverable();
          }
     }
1.3 请求用户授权，让设备可被其它临近设备发现：
     // 请求用户授权，让设备在120秒内处于可发现状态
     private void discoverable() {
          Intent discoverableIntent = new Intent(
                    BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
          startActivity(discoverableIntent);
     }

 

2.连接启用蓝牙设备

 
 2.1对于任何蓝牙应用，都必须在AndroidManifst.xml中添加如下权限：
     <uses-permission android:name= "android.permission.BLUETOOTH_ADMIN" />
     <uses-permission android:name= "android.permission.BLUETOOTH" />
 
 2.2 创建到其他蓝牙设备的套接字连接
     我们应该在一个线程内持续监听套接字流中的数据。可以在该线程外写入连接的流。这种连接是一个阻塞调用，由于蓝牙设备发现是一个缓慢的过程，可能降低连接速率。所以，在连接其它设备之前要取消设备发现。
     蓝牙套接字连接时阻塞调用，只在连接成功或者连接设备发生异常时才会返回。BluetoothConnection一经实例化，就会创建到其他设备的连接，并开始监听来自连接设备的数据。
package com.example.blueoothdemo;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;

/**
* 读写蓝牙设备
*
* @author hbbliyong
*
*/
public class BluetoothConnecion extends Thread {
     private final BluetoothSocket mSocket;
     private final InputStream mInStream;
     private final OutputStream mOutStream;
     byte[] buffer;
     private final BluetoothAdapter mAdapter;
     // 用于本应用程序唯一的UUID，
     private static final UUID MY_UUID = UUID
               .fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");

     public BluetoothConnecion(BluetoothDevice device) {
          BluetoothSocket tmp = null;
          mAdapter = BluetoothAdapter.getDefaultAdapter();
          // 获得用于指定蓝牙连接的BluetoothSocket
          try {
               tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
          } catch (Exception e) {
               e.printStackTrace();
          }
          mSocket = tmp;

          // 在新线程中建立套接字连接，避免FC
          Thread connectionThread = new Thread(new Runnable() {
               @Override
               public void run() {
                    // TODO Auto-generated method stub
                    // 始终取消发现，因为它会降低连接的速度
                    mAdapter.cancelDiscovery();

                    // 建立到BluetoothSocket的连接
                    try {
                         // 这是一个阻塞调用，只在成功连接或者异常时返回
                         mSocket.connect();
                    } catch (Exception e) {
                         e.printStackTrace();
                         // 设备连接失败，关闭套接字
                         try {
                              mSocket.close();
                         } catch (Exception e2) {
                              // TODO: handle exception
                              e2.printStackTrace();
                         }
                    }
               }
          });

          connectionThread.start();

          InputStream tmpIn = null;
          OutputStream tmpOut = null;

          // 获得BluetoothSoket输入输出流
          try {
               tmpIn = mSocket.getInputStream();
               tmpOut = mSocket.getOutputStream();
               buffer = new byte[1024];
          } catch (Exception e) {
               e.printStackTrace();
          }
          mInStream = tmpIn;
          mOutStream = tmpOut;
     }

     public void run() {
          // 连接时保持监听InputStream
          while (true) {
               try {
                    // 从套接字流读取数据
                    mInStream.read(buffer);
                    // 向UI Activity发送获取的数据
               } catch (Exception e) {
                    // TODO: handle exception
                    // 这里的异常标志着连接的丢失
                    // 向UI Activity发送获取的数据
                    break;
               }
          }
     }
    
     public void write(byte[] buffer)
     {
          try {
               mOutStream.write(buffer);
          } catch (Exception e) {
               e.printStackTrace();
          }
     }
    
     public void cancel()
     {
          try {
               mSocket.close();
          } catch (Exception e) {
               // TODO: handle exception
               e.printStackTrace();
          }
     }
}
 

3.监听和接收蓝牙连接请求

 
     在两个蓝牙设备交互之前，其中一个通信设备必须起服务器的作用。它获取一个BluetoothServerSocket实例并监听入站请求。这个实例通过调用蓝牙适配器上的listenUsingRfcommWithServiceRecord()方法获得。有了这个实例我们可以通过start（）方法开始监听来自远程设备的入站请求。
 
  //使主设备处于可发现状态
  Intent disCoverableIntent = new Intent(
                      BluetoothAdapter. ACTION_REQUEST_DISCOVERABLE);
  startActivityForResult(disCoverableIntent，DISCOVERY_REQUEST_BLUETOOTH );
 
 
//创建一个蓝牙服务器并接受连接
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 
           if (requestCode == DISCOVERY_REQUEST_BLUETOOTH ) {
               boolean isDiscoverable = resultCode > 0;
               if (isDiscoverable) {
                    // UUID
                    // uuid=UUID.fromString("a60f35f0-b93a-11de-8a39-08002009c666");
                    final UUID uuid = UUID.randomUUID();
                    final String serverName = "BTServer" ;
                    final BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
 
                    final BluetoothServerSocket bluetoothServer;
 
                   Thread listenThread = new Thread(new Runnable() {
 
                         @Override
                         public void run() {
                              // TODO Auto-generated method stub
                              try {
                                  bluetoothServer = bt.listenUsingRfcommWithServiceRecord(serverName, uuid);
　　　　　　　　　　　　　　　　　　　　BluetoothSocket serverSocket = bluetoothServer.accept();
　　　　　　　　　　　　　　　　　　　　myHandleConnectionWiht(serverSocket);
 
                             } catch (Exception e) {
                                  e.printStackTrace();
                                  
                             }
                        }
 
                         private void myHandleConnectionWiht(
                                  BluetoothSocket serverSocket) {
                              // TODO Auto-generated method stub
                             
                        }
 
                   });
                   listenThread.start();
              }
          }
     }


联系
我们