Android蓝牙开发简介

Android蓝牙系统

蓝牙是一种支持设备短距离通信（一般10m内）的无线电技术，可以在众多设备之间进行无线信息交换。

Android系统中的蓝牙模块

Android包含了对蓝牙网络协议栈的支持，使蓝牙设备能够无线连接其他蓝牙设备以便交换数据。

通过使用蓝牙API，一个Android应用程序能够实现如下功能：

- 扫描其他蓝牙设备

- 查询本地蓝牙适配器用于配对蓝牙设备

- 建立RFCOMM信道

- 通过服务发现连接其他设备

- 数据通信

- 管理多个连接

Android平台中蓝牙系统从上到下主要包括Java框架中的BlueTooth类、Android适配库、BlueZ库、驱动程序和协议。

蓝牙模块中的源码

初始化蓝牙芯片

通过BlueZ工具hciattach进行的，命令格式如下：
hciattach [-n] [-p] [-b] [-t timeout] [-s initial_speed] <tty> <type | id> [speed] [flow|noflow] [bdaddr]
type决定了要初始化的设备的型号，可以使用hciattach -1来列出所支持的设备型号。
Hciattach命令内部的工作步骤是：首先打开制定的tty设备，再做一些通用的设置，如flow等， 之后设置波特率为initial_speed，然后根据type调用各自的初始化代码，最后将波特率重新设置为speed。

蓝牙服务

一般不需要自己定义，只需要使用初始化脚本文件init.rc中的默认内容即可。

管理蓝牙电源

可以调用rfkill接口来控制电源管理，如果已经实现了rfkill接口，则无需再进行配置。

和蓝牙相关的类

BluetoothSocket类

BluetoothSocket类基础

Android的蓝牙系统和Socket套接字密切相关，蓝牙端的监听接口和TCP端口类似，都是使用 Socket和ServerSocket类。在服务器端使用BluetoothServerSocket类来创建一个监听服务端口。当一个连接被BluetoothServerSocket所接受，它会返回一个新的BluetoothSocket来管理该连接。在客户端，使用一个单独的BluetoothSocket类去初始化一个外接连接和管理该连接。

最通常使用的蓝牙端口是RFCOMM，它是一个面向连接，通过蓝牙模块进行数据流传输方式，也被称为串行端口规范（SPP）。

创建一个BluetoothSocket去连接到一个已知设备，使用方法BluetoothDevice.createRfcommSocketToServiceRecord()。然后调用connect（）方法去尝试一个面向远程设备的连接。这个调用将被阻塞指导一个连接已经建立或者该链接失效。

当端口连接成功后，通过getInputStream（）和getOutputStream（）来打开I/O流，从而获得各自的InputStream和OutputStream对象。

BluetoothSocket类的线程是安全的，因为close（）方法会马上放弃外界操作并关闭服务器端口。

BluetoothSocket类的公共方法

public void close（）

public void connect（）

public InputStream getInputStream（）

public OutputStream getOutputStream（）

public BluetoothDevice getRemoteDevice（）

BluetoothServerSocket类

BluetoothServerSocket类的公共方法

public BluetoothSocket accept（int timeout）

public BluetoothSocket accept（）

public void close（）

BluetoothAdapter类

BluetoothAdapter类基础

代表本地的蓝牙适配器设备，通过此类可以让用户能执行基本的蓝牙任务，如初始化设备的搜索、查询可匹配的设备集、使用一个已知的MAC地址来初始化一个BluetoothDevice类、创建一个BluetoothServerSocket类以监听其他设备对本机的连接请求等。

调用静态方法getDefaultAdapter（）获得，这是所有蓝牙动作使用的第一步。当拥有本地适配器以后，用户可以获得一系列的BluetoothDevice对象，这些对象代表所有拥有getBondedDevice()方法的已经匹配的设备；用startDiscovery（）方法来开始设备的搜寻；或者创建一个BluetoothServerSocket类，通过listenUsingRfcommWithServiceRecord（String，UUID）方法来监听新来的连接请求。

大部分方法需要BLUETOOTH权限，一些方法同时需要BLUETOOTH_ADMIN权限。

BluetoothAdapter类的常量

String ACTION_DISCOVERY_FINISHED

广播事件：本地蓝牙适配器已经完成设备的搜索过程，需要BLUETOOTH权限接收。
常量值：android.bluetooth.adapter.action.DISCOVERY_FINISHED

String ACTION_DISCOVERY_STARTED

广播事件：本地蓝牙适配器已经开始对远程设备的搜寻过程。用户可以通过cancelDiscovery（）类来取消正在执行的查找过程，需要BLUETOOTH权限接收。
常量值：android.bluetooth.adapter.action.DISCOVERY_STARTED

String ACTION_LOCAL_NAME_CHANGED

广播事件：本地蓝牙适配器已经更改了它的蓝牙名称，需要BLUETOOTH权限接收。
常量值：android.bluetooth.adapter.action.LOCAL_NAME_CHANGED

String ACTION_REQUEST_DISCOVERABLE

Activity活动：显示一个请求被搜寻模式的系统活动。Android运用onActivityResult(int,int,Intent)回收方法来传递该活动结果的通知。需要BLUETOOTH权限。
常量值：android.bluetooth.adapter.action.REQUEST_DISCOVERYABLE

String ACTION_REQUEST_ENABLE

Activity活动：显示一个允许用户打开蓝牙模块的系统活动。Android运用onActivityResult(int,int,Intent)回收方法来传递该活动结果的通知。需要BLUETOOTH权限。
常量值：android.bluetooth.adapte.action.REQUEST_ENABLE

String ACTION_SCAN_MODE_CHANGED

广播活动：指明蓝牙扫描模块或者本地适配器已经发生变化，需要BLUETOOTH权限。
常量值：android.bluetooth.adapter.action.SCAN_MODE_CHANGED

String ACTION_STATE_CHANGED

广播活动：本来的蓝牙适配器的状态已经改变，如蓝牙模块已经被打开或者关闭，需要BLUETOOTH权限接收。
常量值：android.bluetooth.adapter.action.STATE_CHANGED

int ERROR

功能：标记该类的错误值，确保和该类中的任意其他整数常量不相等。它为需要一个标记错误值的函数提供了便利，例如：
Intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,BluetoothAdapter.ERROR);

String EXTRA_DISCOVERABLE_DURATION

功能：试图在ACTION_REQUEST_DISCOVERABLE常量中作为一个可选的整型附加域，来为短时间内的设备发现请求一个特定的持续时间，默认值为120秒，超过300秒的请求将被限制。
常量值：android.bluetooth.adapter.extra.DISCOVERABLE_DURATION

String EXTRA_LOCAL_NAME

功能：试图在ACTION_LOCAL_NAME_CHANGED常量中作为一个字符串附加域，来请求本地蓝牙的名称。
常量值：android.bluetooth.adapter.extra.LOCAL_NAME

String EXTRA_PREVIOUS_SCAN_MODE

功能：试图在ACTION_SCAN_MODE_CHANGED常量中作为一个整型附加域，来请求以前的扫描模式，可能值如下：
SCAN_MODE_NONE
SCAN_MODE_CONNECTABLE
SCAN_MODE_CONNECTABLE_DISCOVERABLE
常量值：android.bluetooth.adapter.extra.PREVIOUS_SCAN_MODE

String EXTRA_PREVIOUS_STATE

功能：试图在ACTION_STATE_CHANGED常量中作为一个整型附加域，来请求以前的供电状态。可能值如下：
STATE_OFF
STATE_TURNING_ON
STATE_ON
STATE_TURNING_OFF
常量：android.bluetooth.adapter.extra.PREVIOUS_STATE

String EXTRA_SCAN_MODE

功能：试图在ACTION_SCAN_MODE_CHANGED常量作为一个整型附加域，来请求当前的扫描模式，可能值如下：
SCAN_MODE_NONE
SCAN_MODE_CONNECTABLE
SCAN_MODE_CONNECTABLE_DISCOVERABLE
常量值：android.bluetooth.adapter.extra.SCAN_MODE

String EXTRA_STATE

功能：试图在ACTION_STATE_CHANGED常量中作为一个整型附加域，来请求当前供电状态，可能值如下：
STATE_OFF
STATE_TURNING_ON
STATE_ON
STATE_TURNING_OFF
常量值：android.bluetooth.adapter.extra.STATE

int SCAN_MODE_CONNECTABLE

功能：指明在本地蓝牙适配器中，查询扫描功能失效，但页面扫描功能有效。因此，该设备不能被远程蓝牙设备发现，但如果以前曾经发现过该设备，则远程设备可以对其进行连接。
常量值：21（0x00000015）

int SCAN_MODE_CONNECTABLE_DISCOVERABLE

功能：指明在本地蓝牙适配器中， 查询扫描功能都有效，因此，该设备既可以被远程蓝牙设备发现，也可以被其连接。
常量值：23（0x00000017）

int SCAN_MODE_NONE

功能：指明在本地蓝牙适配器中，查询扫描功能和页面扫描功能都失效，因此，该设备既不可以被远程蓝牙设备发现，也不可以被连接。
常量值：20（0x00000014）

int STATE_OFF

功能：指明本地蓝牙适配器模式已经关闭
常量值：10（0x0000000a）

int STATE_ON

功能：指明本地蓝牙适配器模块已经打开，并且准备被使用

int STATE_TURNING_OFF

功能：指明本地蓝牙适配器模块正在关闭。本地客户端可以立刻尝试友好地断开任意外部连接。
常量值：13（0x0000000d）

int STATE_TURNING_ON

功能：指明本地蓝牙适配器模块正在打开，然而本地客户在尝试使用这个适配器之前需要为STATE_ON状态而等待
常量值：11（0x000000b）

BluetoothAdapter类的公共方法

public boolean cancelDiscovery()

public static boolean checkBluetoothAddress(String address)

public boolean disable()

public boolean enable()

public String getAddress()

public Set getBondedDevices()

public static synchronized BluetoothAdapter getDefaultAdapter()

public String getName()

public BluetoothDevice getRemoteDevice(String address)

public int getScanMode()

public int getState()

public boolean isDiscovering()

public boolean isEnabled()

public BluetoothServerSocket ListenUsingRfcommWithServiceRecord(String name,UUID uuid)

public boolean setName(String name)

public boolean startDiscovery()

BluetoothClass.Service类

用于定义所有的服务类常量，任意BluetoothClass由0或多个服务类编码组成。在类BluetoothClass.Service中包含如下常量：

int AUDIO

int CAPTURE

int INFORMATION

int LIMITED_DISCOVERABILITY

int NETWORKING

int OBJECT_TRANSFER

int POSITIONING

int RENDER

int TELEPHONY

BluetoothClass.Device类

用于定义所有的设备类的常量，每个BluetoothClass有一个带有主要和较小部分的设备类进行编码，里面的常量代表主要和较小的设备类部分（完整的设备类）的组合。

在Android平台开发蓝牙应用程序

1.设置权限

<uses-permission android:name="android.permission.BLUETOOTH"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>

2.启动蓝牙

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if(mBluetoothAdapter == null){
//表示手机不支持蓝牙
return;
}
if(!mBluetoothAdapter.isEnabled()){ //蓝牙未开启，则开启蓝牙
Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableIntent,REQUEST_ENABLE_BT);
}
//...
public void onActivityResult(int requestCode,int resultCode,Intent data){
if(requestCode == REQUEST_ENABLE_BT){
if(resultCode == RESULT_OK){
//蓝牙已经开启
}
}
}

3.发现蓝牙设备

//使本机蓝牙在300秒内可被搜索
private void ensureDiscoverable(){
if(mBluethAdapter.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE){
Intent discoverableIntent = new Intent(BluetoothAdapter.ATION_REQUEST_DISCOVERABLE);
intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,300);
startActivity(discoverableIntent);
}
}

//查找已经配对的蓝牙设备，即以前已经配对过的设备
Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
if(pairedDevices.size() > 0){
findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
for(BluetoothDevice device : pairedDevices){
//device.getName() + " " + device.getAddress();
}
}else{
mPairedDevicesArrayAdapter.add("没有找到已配对的设备");
}

//注册，当一个设备被发现时调用onReceive
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
this.registerReceiver(mReceiver,filter);
//当搜索结束后调用onReceive
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
this.registerReceiver(mReceiver,filter);
//...
private BroadcastReceiver mReceiver = new BroadcastReceiver(){
@Override
public void onReceiver(Context context,Intent intent){
String action = intent.getAction();
if(BluetoothDevice.ACTION_FOUND.equal(action)){
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
//已经配对的则跳过
if(device.getBondState() != BluetoothDevice.BOND_BONDED){
mNewDevicesArrayAdapter.add(device.getName()+"\n"+device.getAddress());
}
}else if(BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equal(action)){
//搜索结束
if(mNewDevicesArrayAdapter.getCount() == 0){
mNewDevicesArrayAdapter.add("没有搜索到设备");
}
}
}
}

4.建立连接

//UUID可以看做一个端口号
private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
//像一个服务器一样时刻监听是否有连接建立
private class AcceptThread extend Thread{
private BluetoothServerSocket serverSocket;
public AcceptThread(boolean secure){
BluetoothServerSocket temp = null;
try{
temp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME_INSECURE,MY_UUID);
}catch(IOException e){
Log.e("TAG","listen() failed "+e);
}
serverSocket = temp;
}

public void run(){
BluetoothSocket socket = null;
while(true){
try{
socket = serverSocket.accept();
}catch(IOException e){
Log.e("TAG","accept() failed "+e);
break;
}
}
if(socket != null){
//此时可以新建一个数据交换线程，把此socket传进去
}
}

//取消监听
public void cancel(){
try{
serverSocket.close();
}catch(){
Log.e("TAG","Socket Type "+socketType+" close() of server failed "+e);
}
}
}

5.交换数据

//另一个设备去连接本机，相当于客户端
private class ConnectThread extends Thread{
private BluetoothSocket socket;
private BluetoothDevice device;
public ConnectThread(BluetoothDevice device,boolean secure){
this.device = device;
BluetoothSocket tmp = null;
try{
tmp = device.createRfcommSocketToServiceRecord(MY_UUID_SECURE);
}catch(IOException e){
Log.e("TAG","create() failed "+e);
}
}

public void run(){
mBluetoothAdapter.cancelDiscovery(); //取消设备查找
try{
socket.connect();
}catch(IOException e){
try{
socket.close();
}catch(IOException e1){
Log.e("TAG","unable to close "+"socket during connection failure "+e1);
}
connectionFailed(); //连接失败
return;
}
//此时可以新建一个数据交换线程，把此socket传进去
}

public void cancel(){
try{
socket.close();
}catch(){
Log.e("TAG","close() of connect socket failed "+e);
}
}
}

6.建立数据通信线程

//建立连接后，进行数据通信的线程
private class ConnectedThread extend Thread{
private BluetoothSocket socket;
private InputStream inStream;
private OutputStream outStream;

public ConnectedThread(BluetoothSocket socket){
this.socket = socket;
try{
//获取输入/输出流
inStream = socket.getInpuStream();
outStream = socket.getOutputStream();
}catch(IOException e){
Log.e("TAG","temp sockets not created "+e);
}
}

public void run(){
byte[] buff = new byte[1024];
int len = 0;
//读取数据需不断监听，写不需要
while(true){
try{
len = inStream.read(buff);
//把读取到的数据发送给UI进行显示
Message msg = handler.obtainMessage(BluetoothChat.MESSAGE_READ,len,-1,buff);
}catch(IOException e){
Log.e("TAG","disconnected "+e);
connectionLost(); //失去连接
start(); //重新启动服务器
break;
}
}
}

public void write(byte[] buffer){
try{
outStream.write(buffer);
handler.obtainMessage(BluetoothChat.MESSAGE_WRITE,-1,-1,buffer);
msg.sendToTarget();
}catch(IOException e){
Log.e("TAG","Exception during write "+e);
}
}

public void cancel(){
try{
socket.close();
}catch(IOException e){
Log.e("TAG","close() of connect socket failed "+e);
}
}
}