初学android蓝牙小结

刚学android，然后想做个蓝牙通信APP，就是扫描设备，配对，然后收发数据。后来从网上找了好多资料，找到一个比较好的DEMO，然后修改了相关代码，基本完成上面的功能，现在把基本用法和API总结如下：

1。蓝牙的打开

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();//获取BluetoothAdapter并判断系统是否支持

if (!mBluetoothAdapter.isEnabled()){//打开蓝牙

    Intent bleIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(bleIntent,request1);
}

2。获取已经配对的设备

Set<BluetoothDevice> pairedDevices;

pairedDevices = mBluetoothAdapter.getBondedDevices();

if (pairedDevices.size() > 0) {

    for (BluetoothDevice device : pairedDevices) {
        mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }

3。扫描新设备

IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter);

// Register for broadcasts when discovery has finished
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
registerReceiver(mReceiver, filter);
// If we're already discovering, stop it
if (mBluetoothAdapter.isDiscovering()) {
    mBluetoothAdapter.cancelDiscovery();
}
// Request discover from BluetoothAdapter
mBluetoothAdapter.startDiscovery();

//添加新设备

private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    @Override
    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);
            // If it's already paired, skip it, because it's been listed already
            if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
            }
            // When discovery is finished, change the Activity title
        } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {

        }
    }
};

4。设备的连接

private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
    private String mSocketType;



    public ConnectThread(BluetoothDevice device, boolean secure) {
        mmDevice = device;
        BluetoothSocket tmp = null;
        mSocketType = secure ? "Secure" : "Insecure";

        try {
            if (secure) {
                tmp = device.createRfcommSocketToServiceRecord(
                        MY_UUID_SECURE);
            } else {
                tmp = device.createInsecureRfcommSocketToServiceRecord(
                        MY_UUID_INSECURE);
            }
        } catch (IOException e) {
            Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
        }
        mmSocket = tmp;

    }
    @Override
    public void run() {
        setName("ConnectThread" + mSocketType);
        mAdapter.cancelDiscovery();
        try {
            mmSocket.connect();
        } catch (IOException e) {
            try {
                mmSocket.close();
            } catch (IOException e2) {
            }
            connectionFailed();
            return;
        }
        synchronized (BlueToothService.this) {
            mConnectThread = null;
        }

        connected(mmSocket, mmDevice, mSocketType);
    }

    public void cancel() {

        try {
            mmSocket.close();
        } catch (IOException e) {
        }

    }
}

5连接后的数据收发

private class ConnectedThread extends Thread{
    private final BluetoothSocket mmSocket;
    private final InputStream myInputStream;
    private final OutputStream myOutputStream ;

    public ConnectedThread(BluetoothSocket socket,String sockType)
    {
        InputStream tmp1;
        OutputStream tmp2;
        mmSocket = socket;
        tmp1 = null;
        tmp2 = null;
        try {
            tmp1 = socket.getInputStream();
            tmp2 = socket.getOutputStream();
        }catch (IOException e)
        {
        }
        myInputStream = tmp1;
        myOutputStream = tmp2;
    }
    @Override
    public void run()
    {
        byte[] buffer = new byte[1024];
        int bytes;

        while (true)
        {
            try {
                bytes = myInputStream.read(buffer);
                mHandler.obtainMessage(MainActivity.MESSAGE_READ,bytes,0,buffer).sendToTarget();
            }catch (IOException e){
                connectionLost();
                BlueToothService.this.start();
                break;
            }
        }

    }

    public void write(byte[] buffer)
    {
        try {
            myOutputStream.write(buffer);
            mHandler.obtainMessage(MainActivity.MESSAGE_WRITE,0,0,buffer).sendToTarget();
        }catch (IOException e)
        {

        }
    }
    public void cancel(){
        try{
            mmSocket.close();
        }catch (IOException e)
        {

        }
    }

}

6上面是数据主动连接，下面是建立线程检测别人的连接

private class AcceptThread extends Thread {
    BluetoothServerSocket   bluetoothServerSocket;
    String      mSocketType;

    public  AcceptThread(boolean secure)
    {
        mSocketType = secure ? "Secure":"Insecure";
        BluetoothServerSocket tmp = null;
        try {
            if (false == secure)
            {
                tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME_SECURE,MY_UUID_INSECURE);
            }else {
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_INSECURE,MY_UUID_SECURE);
            }
        }catch (IOException e)
        {

        }
        bluetoothServerSocket = tmp;
    }
    @Override
    public void run()
    {
        setName("AcceptThread" + mSocketType);
        BluetoothSocket socket = null;

        while (myState != STATE_CONNECTED)
        {
            try {
                socket = bluetoothServerSocket.accept();
            }catch (IOException e)
            {
            }
            // If a connection was accepted
            if (socket != null) {
                synchronized (BlueToothService.this) {
                    switch (myState) {
                        case STATE_LISTEN:
                        case STATE_CONNECTING:
                            // Situation normal. Start the connected thread.
                            connected(socket, socket.getRemoteDevice(), mSocketType);
                            break;
                        case STATE_NONE:
                        case STATE_CONNECTED:
                            // Either not ready or already connected. Terminate new socket.
                            try {
                                socket.close();
                            } catch (IOException e) {
                                Log.e(TAG, "Could not close unwanted socket", e);
                            }
                            break;
                    }
                }
            }
        }
    }
    public void cancel()
    {

    }
}

//以上基本完成了蓝牙的打开，扫描，配对，连接，收发的功能

声明：源码是参照网上相关DEMO修改，并不是原创，本人只是在参考学习后做了相关总结。谢谢