Android平台提供了对蓝牙网络协议栈的支持，它允许设备通过无线的方式与其它设备进行数据交换。应用程序框架通过Android Bluetooth APIs提供了对蓝牙功能的访问。这些API允许应用以无线的方式连接其它蓝牙设备，启用点对点或者多点对多点的无线功能。使用蓝牙的API，Android应用程序可以执行以下工作：

* 扫描其它蓝牙设备
* 查询本地蓝牙适配器以配对蓝牙设备
* 建立RFCOMM通道
* 通过服务搜索连接其它设备
* 传输或者接收其它设备的数据
* 管理多个连接

本文档描述了如何使用Classic Bluetooth（传统蓝牙）。传统蓝牙是耗电操作的理想选择，例如Android设备之间的数据流传输和通讯。为了适应低能耗蓝牙设备，Android 4.3（API Level 18）的API开始支持Bluetooth Low Energy（BLE）。更多信息，请参考Bluetooth Low Energy。

1、The Basics（基础部分）

1.1 BluetoothAdapter

1.2 BluetoothDevice

1.3 BluetoothSocket

1.4 BluetoothServerSocket

1.5 BluetoothClass

1.6 BluetoothProfile

1.7 BluetoothHeadset

1.8 BluetoothA2dp

1.9 BluetoothHealth

1.10 BluetoothHealthCallback

1.11 BluetoothHealthAppConfiguration

1.12 BluetoothProfile.ServiceListener

2、Bluetooth Permission（蓝牙权限）

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

3、Setting up Bluetooth（设置蓝牙）

3.1 获取BluetoothAdapter

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
    // 设备不支持蓝牙
}

3.2 启用蓝牙

if (!mBluetoothAdapter.isEnabled()) {
    Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}

将会出现一个对话框请求用户授权启用蓝牙，如图。如果用户点击“Yes”，系统将会启用蓝牙，焦点也会在程序完成（或者失败）之后返回到你的应用程序。

4、Finding Devices（搜索设备）

4.1 Querying paired devices（查询配对设备）

Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// 如果有已配对设备
if (pairedDevices.size() > 0) {
    // 循环查看已配对设备
    for (BluetoothDevice device : pairedDevices) {
        // 添加名字和地址到一个ArrayAdapter中，以便在ListView中显示
        mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }
}

4.2 Discovering devices（搜索设备）

// 创建一个监听ACTION_FOUND的BroadcastReceiver
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // 当发现了一个设备
        if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // 从Intent中获取BluetoothDevice对象
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            // 将名字和地址添加到ListView的ArrayAdapter中
            mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
};
// 注册这个BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // 不要忘记在onDestroy方法中注销这个广播

4.3 Enabling discoverability（启用可被发现模式）

Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivityForResult(discoverableIntent, REQUEST_DISCOVERABLE);//REQUEST_DISCOVERABLE为自定义的requestcode值

注意：如果设备没有启用蓝牙，那么启用设备的蓝牙可被发现模式会自动启用设备蓝牙。

5、Connecting Devices（连接设备）

注意：如果两台设备之前没有配对，那么Android Framework将会在连接过程中自动提示配对请求信息或者对话框，如图。因此尝试连接其它设备的时候，你的应用程序不需要考虑设备是否已经配对。你的RFCOMM连接将会被阻塞，直到用户配对成功或者失败（用户拒绝配对，或者配对失败，或者超时）。

5.1 Connecting as server（作为服务端连接）

private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;
 
    public AcceptThread() {
        // 使用一个临时对象，稍后赋值给mmServerSocket,
        // 因为mmServerSocket被声明为final
        BluetoothServerSocket tmp = null;
        try {
            // MY_UUID是应用的UUID字符串,同样也会在客户端的代码中使用到
            tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }
 
    public void run() {
        BluetoothSocket socket = null;
        // 保持监听知道出现异常或者返回一个socket
        while (true) {
            try {
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // 如果接受了一个连接
            if (socket != null) {
                // 执行连接的管理操作(在一个独立的线程中)
                manageConnectedSocket(socket);
                mmServerSocket.close();
                break;
            }
        }
    }
 
    /** 将会终止socket的监听，并让线程结束 */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}

5.2 Connecting as a client（作为客户端连接）

private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
 
    public ConnectThread(BluetoothDevice device) {
        // 使用临时对象稍候赋值给mmSocket,
        // 因为mmSocket的类型是final
        BluetoothSocket tmp = null;
        mmDevice = device;
 
        // 获取一个BluetoothSocket来连接给定的BluetoothDevice
        try {
            // MY_UUID是应用的UUID字符串, 也是服务端使用的UUID字符串
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }
 
    public void run() {
        // 取消扫描设备，因为扫描会让连接速度变慢
        mBluetoothAdapter.cancelDiscovery();
 
        try {
            // 通过socket连接设备,这将会阻塞
            // 直到连接成功或者抛出异常
            mmSocket.connect();
        } catch (IOException connectException) {
            // 连接失败;关闭socket并退出
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }
 
        // 进行连接管理的操作 (在一个指定的线程中)
        manageConnectedSocket(mmSocket);
    }
 
    /** 将会取消正在进行中的连接,并关闭socket */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

6、Managing a Connection（管理连接）

private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;
 
    public ConnectedThread(BluetoothSocket socket) {
        mmSocket = socket;
        InputStream tmpIn = null;
        OutputStream tmpOut = null;
 
        // 使用临时对象获取输入输出流，
        // 因为成员输入输出流的类型是fianl
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }
 
        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }
 
    public void run() {
        byte[] buffer = new byte[1024];  // 数据流的数据缓冲区
        int bytes; // 从read()方法返回的字节数
 
        // 保持对InputStream的监听，直到有异常抛出
        while (true) {
            try {
                // 从InputStream中读取数据
                bytes = mmInStream.read(buffer);
                // 将获取的字节发送到UI activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                break;
            }
        }
    }
 
    /* 在main activity中调用这个方法将数据发送到远程设备 */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }
 
    /* 在main activity中调用这个方法来停止连接 */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

7、Working with Profile（使用Profile）

BluetoothHeadset mBluetoothHeadset;
 
// 获取默认的adapter
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
 
// 建立与代理的连接
mBluetoothAdapter.getProfileProxy(context, mProfileListener, BluetoothProfile.HEADSET);
 
private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() {
    public void onServiceConnected(int profile, BluetoothProfile proxy) {
        if (profile == BluetoothProfile.HEADSET) {
            mBluetoothHeadset = (BluetoothHeadset) proxy;
        }
    }
    public void onServiceDisconnected(int profile) {
        if (profile == BluetoothProfile.HEADSET) {
            mBluetoothHeadset = null;
        }
    }
};
 
// ... 调用mBluetoothHeadset的方法
 
// 使用完之后关闭代理连接
mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset);

7.1 Vendor-specific AT commands（特定于供应商的AT命令）

7.2 Health Device Profile（健康设备的Profile）

7.3 Creating an HDP Application（创建一个HDP应用程序）

（5）完成之后，关闭健康通道并注销应用程序。当有扩展活动的时候，这个通道同样会被关闭。

Android蓝牙