Android蓝牙通用数据传输之一(SPP)


Android蓝牙通用数据传输之一(SPP)_第1张图片

 

一、引言

Android蓝牙中涉及通用数据传输协议的有两种:

  • SPP协议
  • BLE(Bluetooth low energy)协议

SPP协议是Android 2.0引入的API,是通过Socket的形式来实现数据传输及交互,有分客户端和服务端,手机一般以客户端的角色主动连接SPP协议设备。
BLE协议是Android 4.3引入的API,但手机厂商大部份在Android 4.4上才支持BLE,即低功耗蓝牙,一般我们开发的话是使用中央(BluetoothGatt)或者外围(BluetoothGattServer)来进行开发的,手机正常情况下当作中央设备来接收信息,而蓝牙模块当作是外围设备发送数据。

二、SPP协议

SPP协议的连接流程:

  • 使用registerReceiver注册BroadcastReceiver来获取蓝牙状态、搜索设备等消息
  • 在BroadcastReceiver的onReceive()里取得搜索所得的蓝牙设备信息(如名称,MAC,RSSI)
  • 通过设备的MAC地址来建立一个BluetoothDevice对象
  • 由BluetoothDevice衍生出BluetoothSocket,准备SOCKET来读写设备
  • 通过BluetoothSocket的createRfcommSocketToServiceRecord()方法来选择连接的协议/服务,默认是SPP(UUID:00001101-0000-1000-8000-00805F9B34FB)
  • Connect之后(如果还没配对则系统自动提示),使用BluetoothSocket的getInputStream()和getOutputStream()来读写蓝牙设备
  • 关闭数据接口

SPP协议涉及4个类:

  • BluetoothAdapter:代表本地蓝牙适配器,是所有蓝牙交互的入口。使用这个你可以发现其他蓝牙设备,查询已配对的设备列表,使用一个已知的MAC地址来实例化一个BluetoothDevice,以及创建一个BluetoothServerSocket来为监听与其他设备的通信
  • BluetoothDevice:代表一个远程蓝牙设备,使用这个来请求一个与远程设备的BluetoothSocket连接,或者查询关于设备名称、地址、类和连接状态等设备信息
  • BluetoothSocket:代表一个蓝牙socket的接口(和TCP Socket类似)。这是一个连接点,它允许一个应用与其他蓝牙设备通过InputStream和OutputStream交换数据
  • BluetoothServerSocket:代表一个开放的服务器socket,它监听接受的请求(与TCP ServerSocket类似)。为了连接两台Android设备,一个设备必须使用这个类开启一个服务器socket。当一个远程蓝牙设备开始一个和该设备的连接请求,BluetoothServerSocket将会返回一个已连接的BluetoothSocket,接受该连接

获取本地蓝牙适配器:

    public static BluetoothAdapter getBtAdapter() {
        Context mContext = CSmartApplication.getInstance().getApplicationContext();
        BluetoothManager bluetoothManager = (BluetoothManager) mContext
                .getSystemService(Context.BLUETOOTH_SERVICE);
        return bluetoothManager.getAdapter();
    }

注册监听:

    private void requestProfileConnectionState() {
        //检测连接状态:
        int a2dp = mBluetoothAdapter.getProfileConnectionState(BluetoothProfile.A2DP);
        int gatt = mBluetoothAdapter.getProfileConnectionState(BluetoothProfile.GATT);
        int sap = mBluetoothAdapter.getProfileConnectionState(BluetoothProfile.SAP);
        //据是否有连接获取已连接的设备
        int flag = -1;
        if (a2dp == BluetoothProfile.STATE_CONNECTED) {
            flag = a2dp;
        } else if (gatt == BluetoothProfile.STATE_CONNECTED) {
            flag = gatt;
        } else if (sap == BluetoothProfile.STATE_CONNECTED) {
            flag = sap;
        }
        if (flag != -1) {
            ProxyListener mProxyListener = new ProxyListener();
            mBluetoothAdapter.getProfileProxy(this, mProxyListener, flag);
        }
    }

    private void listenBlueState() {
        //检查当前是否存在蓝牙连接
        requestProfileConnectionState();
        if (mFondDevieReceiver == null) {
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
            intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
            mFondDevieReceiver = new FoundDeviceReceiver();
            registerReceiver(mFondDevieReceiver, intentFilter);
        }
    }


获取远程蓝牙设备:

 private class ProxyListener implements BluetoothProfile.ServiceListener {

        @Override
        public void onServiceConnected(int profile, BluetoothProfile proxy) {

            if (proxy != null) {
                List mDevices = proxy.getConnectedDevices();
                if (mDevices.size() > 0) {
                    for (int i = 0; i < mDevices.size(); i++) {
                        //获取BluetoothDevice
                        mDevice = mDevices.get(0);
                        logShow("mDevice: " + mDevices.get(0).getAddress());
                        //调用创建Socket连接
                        connectDevice();
                    }
                }
                mBluetoothAdapter.closeProfileProxy(profile, proxy);
            }
        }

        @Override
        public void onServiceDisconnected(int profile) {

        }
    }


    private class FoundDeviceReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED.equals(action)
                    || BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {

                int a2dpState = intent.getIntExtra(BluetoothA2dp.EXTRA_STATE, -1);
                int adapterState = intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE, BluetoothAdapter.ERROR);
                if (BluetoothA2dp.STATE_CONNECTED == a2dpState || BluetoothAdapter.STATE_CONNECTED == adapterState) {//连接成功
                    //获取BluetoothDevice
                    mDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    logShow("STATE_CONNECTED: " + mDevice.getAddress());
                    //调用创建Socket连接
                    connectDevice();
                } else if (BluetoothA2dp.STATE_CONNECTING == a2dpState) {//正在连接
                } else if (BluetoothA2dp.STATE_DISCONNECTED == a2dpState) {//取消连接
                    logShow("STATE_DISCONNECTED");
                    ......
                }
            }
            if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
                        BluetoothAdapter.ERROR);
                switch (state) {
                    case BluetoothAdapter.STATE_OFF:
                        break;
                    case BluetoothAdapter.STATE_TURNING_OFF:
                        break;
                    case BluetoothAdapter.STATE_ON:
                        break;
                    case BluetoothAdapter.STATE_TURNING_ON:
                        break;
                }
            }
        }
    }

创建Socket:

创建RFCOMM的UUID需要与设备端约定,一般使用默认的就可以,但有时因项目特殊,也会另有定义。

 private static final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");//默认UUID
    /**
     * Create the RFCOMM bluetooth socket.
     *
     * @param uuid UUID to create the socket with.
     * @return BluetoothSocket object.
     */
    @TargetApi(10)
    private BluetoothSocket createSocket(UUID uuid) {
        BluetoothSocket socket = null;
        try {
            if (VERSION.SDK_INT >= 10) {
                socket = mBTDevice.createInsecureRfcommSocketToServiceRecord(uuid);
            } else {
                socket = mBTDevice.createRfcommSocketToServiceRecord(uuid);
            }
        } catch (IOException e) {
            if (mDebug)
                Log.e(TAG, "createSocket: " + e.toString());
            try {
                Method method = mBTDevice.getClass().getMethod("createRfcommSocket", new Class[]{int.class});
                socket = (BluetoothSocket) method.invoke(mBTDevice, Integer.valueOf(1));
                return socket;
            } catch (Exception e1) {
                if (mDebug)
                    handleException("createSocket", TypeException.CONNECTION_FAILED, e1);
            }
        }

        return socket;
    }

数据读写:

注:mInputStream.read(buffer)是I/O口堵塞式的

    mBTSocket.connect();
    mInputStream = mBTSocket.getInputStream();

    //启动新线程去处理
    while (this.going) {
        if (mInputStream != null) {
            try {
                int bytes = mInputStream.read(buffer);
                if (bytes < 0) {
                    this.going = false;
                } else {
                    Log.e(TAG, "buffer: " + Arrays.toString(buffer));
                    //数据解析
                    mHandler.obtainMessage(Message.MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
                }
            } catch (Exception e) {
                Log.e(TAG, "mInputStream read is null");
                this.going = false;
            }
        }
    }
    public void sendData(byte[] data) {
        if (!this.mDfuBusy) {//判断连接是否有效
            if (mBTSocket == null) {
                Log.e(TAG, "sendCommandData: not connected.");
                return;
            }
            try {
                OutputStream outputStream = mBTSocket.getOutputStream();
                if (outputStream != null) {
                    try {
                        outputStream.write(data);
                    } catch (Exception e) {
                        Log.e(TAG, "outputStream.write null");
                    }
                } else {
                    Log.e(TAG, "outputStream is null");
                }
            } catch (IOException e) {
                Log.e(TAG, "sendData: " + e);
            }
        }
    }

接口关闭:

    private void disconnectBluetooth() {
        if (mDebug) {
            Log.i(TAG, "disconnect BT");
        }
        if (mBTSocket != null) {
            try {
                if (mInputStream != null) {
                    mInputStream.close();
                    mInputStream = null;
                }
                if (mBTSocket != null) {
                    if (mBTSocket.getInputStream() != null) {
                        mBTSocket.getInputStream().close();
                    }
                }
                if (mBTSocket != null) {
                    if (mBTSocket.getOutputStream() != null) {
                        mBTSocket.getOutputStream().close();
                    }
                }
                if (mBTSocket != null) {
                    mBTSocket.close();
                }
                mBTSocket = null;
                mBTDevice = null;
            } catch (IOException e) {
                if (mDebug) {
                    Log.e(TAG, e.toString());
                }
            }
        }
    }

服务端的Socket建立与客户端差不多,需注意以下两个步骤:

  • 创建监听listen(蓝牙没有此监听,但需要通过whlie(true)死循环来一直监听的)
  • 通过accept(),如果有客户端连接,会创建一个新的Socket,体现出并发性,可以同时与多个socket通讯)

总之:SPP的连接和操作相对比较简单,考虑的事情也少。需要注意的是频繁数据发送(间隔时间短)的情况下,APP收到的数据并不是按原先约定的TLV一包一包数据,可能会被拆包,应对的办法就是启动线程接收完数据,然后去一包一包取。


参考

  • Bluetooth : API
  • SPP : UUID

你可能感兴趣的:(android)