android蓝牙源代码分析_android 蓝牙模块源码分析

为了过bluetooth的PTS测试，最近研究蓝牙相关的android源代码，发现很多不错的文章，这里准备研究一下下面一些列的博客连载文章。下面链接是一系列蓝牙源码分析的连载博客。希望看完后有所帮助。

https://blog.csdn.net/shichaog/article/category/6445694/2

https://blog.csdn.net/u012439416/article/category/6475898

这里贴上第一篇内容：

安卓蓝牙应用程序编写步骤

 

1.获得BluetoothAdapter，对任何Bluetooth Activity都需要先获得。获取方法是调用getDefaultAdapter()方法。

 ​BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
    // Device does not support Bluetooth
}

getDefaultAdapter方法定义于<frameworks/base/core/java/android/bluetooth/bluetoothAdapter.java>

 ​    public static synchronized BluetoothAdapter getDefaultAdapter() {
        if (sAdapter == null) {
            IBinder b = ServiceManager.getService(BLUETOOTH_MANAGER_SERVICE);
            if (b != null) {
                IBluetoothManager managerService = IBluetoothManager.Stub.asInterface(b);
                sAdapter = new BluetoothAdapter(managerService);
            } else {
                Log.e(TAG, "Bluetooth binder is null");
            }
        }
        return sAdapter;
    }
    /**
     * Use {@link #getDefaultAdapter} to get the BluetoothAdapter instance.
     */
    BluetoothAdapter(IBluetoothManager managerService) {
 
        if (managerService == null) {
            throw new IllegalArgumentException("bluetooth manager service is null");
        }
        try {
            mService = managerService.registerAdapter(mManagerCallback);
        } catch (RemoteException e) {Log.e(TAG, "", e);}
        mManagerService = managerService;
        mLeScanClients = new HashMap<LeScanCallback, ScanCallback>();
        mToken = new Binder();
    }

2.使能Bluetooth

调用isEnabled()方法检查蓝牙是否已经使能。如果返回false，则说明蓝牙并未打开，调用startActivityForResult() 方法，并传递ACTION_REQUEST_ENABLE intent，这将会使蓝牙打开。

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

isEnable定义于<frameworks/base/core/java/android/bluetooth/bluetoothAdapter.java>

 ​    @RequiresPermission(Manifest.permission.BLUETOOTH)
    public boolean isEnabled() {
        try {
            synchronized(mManagerCallback) {
                if (mService != null) return mService.isEnabled();
            }
        } catch (RemoteException e) {Log.e(TAG, "", e);}
        return false;
    }

startActivityForResult定义于<base/core/java/android/app/Activity.java>

 ​    public void startActivityForResult(Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
    }

这时会跳出用户许可对话框。

设备发现

使用BluetoothAdapter，不论是通过设备发现或者查询配对设备列表可以发现Bluetooth设备，设备发现是一个扫描本地蓝牙设备的过程。如果一个设备是可发现的，其将通过共享一些信息响应发现请求，这些信息如设备名，类型，MAC地址等。使用这些信息，使用这写信息，发起设备发现的设备可以和一个发现的设备进行配对。

    一旦和其它设备首次建立连接，一个配对请求自动呈现给用户。当配对完成后，设备的基本信息（设备名，类型，MAC地址）将被保存并且可以使用Bluetooth API读取。使用已知的MAC地址可以经行远程配对而不需要执行发现（假设设备在其范围）。

    配对完成和连接是有区别的，配对意味着设备双方都知道对方的存在并且有一个共享的link-key用于授权。并且双方能否建立加密连接。连接意味着设备当前共享一个RFCOMM通道并且双方能够传递数据。

当前Bluedroid API要求先配对才能建立RFCOMM通道。

   查询配对设备

在设备发现之前，查询配对设备集合是有意义的，这可以知道期望配对的设备是否已知了。这可以通过getBoundDevices()实现，其返回BluetoothDevices集合。

 ​Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
    // Loop through paired devices
    for (BluetoothDevice device : pairedDevices) {
        // Add the name and address to an array adapter to show in a ListView
        mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }
}

getBondedDevices定义于<frameworks/base/core/java/android/bluetooth/BluetoothAdapter.java>

 ​    public Set<BluetoothDevice> getBondedDevices() {
        if (getState() != STATE_ON) {
            return toDeviceSet(new BluetoothDevice[0]);
        }
        try {
            synchronized(mManagerCallback) {
                if (mService != null) return toDeviceSet(mService.getBondedDevices());
            }
            return toDeviceSet(new BluetoothDevice[0]);
        } catch (RemoteException e) {Log.e(TAG, "", e);}
        return null;
    }

设备发现

调用startDiscovery()启动设备发现。该过程是异步进行的，立即返回的值表明设备发现是否启动。这一过程差不多需要12秒，然后对每一个查到的设备进行页扫以获得其Bluetooth名称。

    为了接收发现每一个设备的信息，应用程序必须为ACTION_FOUND intent注册一个BroadcastReceiver，针对每一个设备，系统将会广播ACTION_FOUND intent内容。该intent包括EXTRA_DEVICE和EXTRA_CLASS标志，分别包含了BluetoothDevice和BluetoothClass信息。

BluetoothDevice这个类定义于<frameworks/base/core/java/android/bluetooth/BluetoothDevice.java>

 ​// Create a BroadcastReceiver for ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // When discovery finds a device
        if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // Get the BluetoothDevice object from the Intent
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            // Add the name and address to an array adapter to show in a ListView
            mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
};
// Register the BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy

使能发现能力

如果想使设备自身能够被其它设备发现，调用startActivityForResult(Intent, int)方法，并传递ACTION_REQUEST_DISCOVERABLE intent。这将通过系统设置发出使能发现请求，缺省状态下，设备被发现的时间在120s内。但是可以通过EXTRA_DISCOVERABLE_DURATION进行修改该时长。最长可为3600s。

 ​Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);

这时将弹出一个对话框，请求用户允许设备发现，如果用户使能，则onActivityResult()回调将被调用。设备将在设定的时间内可被发现。如果想在发现模式变化时被通知，需要为ACTION_SCAN_MODE_CHANGED Intent注册BroadcastReceiver，这将包括EXTRA_SCAN_MODE和EXTRA_PREVIOUS_SCAN_MODE字段，其分别指示的是新旧扫描模式。可能的值是SCAN_MODE_CNONNECTABLE_DISCOVERABLE和SCAN_MODE_CONNECTABLE或者SCAN_MODE_NONE。

连接设备

为了将两个设备上的应用程序建立连接，必须实现server端和client端，这时因为一个设备必须打开sever socket，而另一个设备必须初始化连接（使用server设备的MAC地址初始化连接）。只有当server和client在相同的RFCOMM通道有一个已连接的BluetoothSocket。到此，每一个设备能够获得输入和输出流，数据传输可以进行了，数据传输在管理连接里叙述。此节描述如何在两个设备上初始化连接。

    server和client 设备用不同的方式获得BluetoothSocket。server端在连接建立被接受时获得，client端在为server端打开RFCOMM通道是获得。

    一个实现的技术是自动将每一个设备作为server，如此可以让每一个设备有打开并用于侦听的server socket。然后两个设备之间可以互连。

作为server连接

    当连接两个设备时，其中一个设备必须通过保持一个打开的BluetoothServerSocket作为server角色。server socket的作用是侦听接收到的连接请求，当其中一方接受时，提供一个建立连接的BluetoothScoket。当BluetoothSocket从BluetoothServerSocket获得时，除非希望接收更多的连接，否则BluetoothServerSocket应该被丢弃。

    建立server socket和接收连接的基本步骤如下：

    1.通过调用listenUsingRfcommWithServiceRecord（String， UUID）获得BluetoothServerSocket。

    String是服务的名称，系统会自动将该服务写入到服务发现协议（Service Discovery Protocol，SDP）。UUID也在SDP里并且是client连接通过的基础。

   2. 调用accept()启动连接侦听

    阻塞调用，当建立连接完成或者遇到特殊情况将会返回。只有当远端设备使用和这里的侦听socket一致的UUID发送连接请求时，这个连接才是可被接受的。当连接建立后accept()将会返回连接的BluetoothSocket()。

  3. 如果不想接收其它连接，调用close()。

    这将释放server端socket。但并不关闭由accept()返回的建立连接的BluetoothSocket。和TCP/IP不同的是，RFCOMM每个通道在一个时刻只允许一个连接的client。主activity并不适合使用阻塞的accept，通常在thread中实现。

 ​private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;
 
    public AcceptThread() {
        // Use a temporary object that is later assigned to mmServerSocket,
        // because mmServerSocket is final
        BluetoothServerSocket tmp = null;
        try {
            // MY_UUID is the app's UUID string, also used by the client code
            tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }
 
    public void run() {
        BluetoothSocket socket = null;
        // Keep listening until exception occurs or a socket is returned
        while (true) {
            try {
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // If a connection was accepted
            if (socket != null) {
                // Do work to manage the connection (in a separate thread)
                manageConnectedSocket(socket);
                mmServerSocket.close();
                break;
            }
        }
    }
 
    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}

连接client

为了和远端的设备相连，首先应获得表示远端设备的BluetoothDevice对象，需要使用BluetoothDevice 接收BluetoothSocket 并且初始化连接。

主要过程如下：

    1.使用BluetoothDevice，通过调用createRfcommSocketToServiceRecord（UUID）获得BluetoothSocket

    这初始化了将连接到BluetoothDevice的BluetoothSocket。这里传递的UUID必须和server端设备使用的保持一致，使用一样的UUID是硬编码UUID到应用程序。

    2.使用connect()初始化连接

    该调用会引起系统执行远端设备SDP查找以匹配UUID。如果成功查找并且远端设备接受连接，connect()将会返回，在连接时RFCOMM通道将共享。

 ​private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
 
    public ConnectThread(BluetoothDevice device) {
        // Use a temporary object that is later assigned to mmSocket,
        // because mmSocket is final
        BluetoothSocket tmp = null;
        mmDevice = device;
 
        // Get a BluetoothSocket to connect with the given BluetoothDevice
        try {
            // MY_UUID is the app's UUID string, also used by the server code
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }
 
    public void run() {
        // Cancel discovery because it will slow down the connection
        mBluetoothAdapter.cancelDiscovery();
 
        try {
            // Connect the device through the socket. This will block
            // until it succeeds or throws an exception
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and get out
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }
 
        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(mmSocket);
    }
 
    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

连接管理

当多个设备成功建立连接时，每一个设备都有一个连接的BluetoothSocket。通过其可以让设备间共享数据。使用BluetoothSocket，传递任意数据的过程是比较简单的。

1.使用getInputStream()和getOutputStream()分别获得InputStream和OutputStream的socket传输句柄。

2.使用read（byte[]）和write（byte[]）向stream中写入数据

使用应该使用专用的thread服务与所有的stream reading和writing。

 ​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;
 
        // Get the input and output streams, using temp objects because
        // member streams are final
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }
 
        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }
 
    public void run() {
        byte[] buffer = new byte[1024];  // buffer store for the stream
        int bytes; // bytes returned from read()
 
        // Keep listening to the InputStream until an exception occurs
        while (true) {
            try {
                // Read from the InputStream
                bytes = mmInStream.read(buffer);
                // Send the obtained bytes to the UI activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                break;
            }
        }
    }
 
    /* Call this from the main activity to send data to the remote device */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }
 
    /* Call this from the main activity to shutdown the connection */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

如何使用profile

profile是两个设备基于蓝牙通信的无线接口规范。一个例子是Hands-Free profile。对于手机连接到无线耳机情景，两个设备必须都支持Hands-Free profile。

可以使用BluetoothProfile创建一个特殊自有的profile。安卓蓝牙API支持以下Bluetooth profile。

Headset。耳机和手机见的profile，BluetoothHeadset类，

A2DP, BluetoothA2dp

Health Device。

使用profile的基本步骤如下

1.获得默认的adapter

2.使用getProfileProxy()建立profile代理对象和profile之间的连接

3.建立BluetoothProfile.ServerListener。

4.在onServiceConnected()，获得profile代理对象的句柄。

5.一旦获得profile代理，可以使用其检测连接状态，或者执行profile能够提供的功能。

 ​BluetoothHeadset mBluetoothHeadset;
 
// Get the default adapter
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
 
// Establish connection to the proxy.
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;
        }
    }
};
 
// ... call functions on mBluetoothHeadset
 
// Close proxy connection after use.
mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset);