Android(安卓)蓝牙服务端实现

package com.ibrobo.robotbingo.common.bluetooth.service;import android.bluetooth.BluetoothServerSocket;import android.bluetooth.BluetoothAdapter;import com.infrastructure.utils.LogUtils;import android.bluetooth.BluetoothSocket;import android.os.HandlerThread;import java.io.OutputStream;import java.io.InputStream;import android.os.Message;import android.os.Handler;import android.os.Looper;import java.util.UUID;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.atomic.AtomicBoolean;/** * 蓝牙通信基础服务框架 * BluetoothBaseService */public class BBS {    private static final int MSG_BLUETOOTH_START = 0;     //蓝牙开始    private static final int MSG_BLUETOOTH_CLOSE = 1;     //蓝牙关闭    private static final int MSG_BLUETOOTH_LISTEN = 2;    //蓝牙监听    private static final int MSG_BLUETOOTH_CONNECTED = 3; //蓝牙连接    private final BluetoothAdapter mBluetoothAdapter;              //蓝牙操作Adapter    private BluetoothStatusHandler mBluetoothStatusHandler = null;  //蓝牙工作处理集    private BluetoothReadHandler mBluetoothReadHandler = null;      //蓝牙工作处理集    public BBS(){        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();        HandlerThread handlerThread1 = new HandlerThread("BluetoothStatusHandler");        handlerThread1.start();        mBluetoothStatusHandler = new BluetoothStatusHandler(handlerThread1.getLooper());        HandlerThread handlerThread2 = new HandlerThread("BluetoothReadHandler");        handlerThread2.start();        mBluetoothReadHandler = new BluetoothReadHandler(handlerThread2.getLooper());    }    private static final int READ_OPEN = 1;    private static final int READ_CLOSE = 2;    private static final int READ = 3;    private class BluetoothReadHandler extends Handler{        private AtomicBoolean isOpen = new AtomicBoolean(false);        BluetoothReadHandler(Looper looper){            super(looper);        }        @Override        public void handleMessage(Message msg) {            int what = msg.what;            switch (what){                case READ:                    if(isOpen.get() && onPushListener != null){                        LogUtils.bluetooth("read input stream....");                        try{                            if (mConnectedHandler != null) {                                mConnectedHandler.read();                            }                        sendEmptyMessage(READ);                        }catch (Exception e){                            e.printStackTrace();                            bluetoothErrorHandler(ERROR_BLUETOOTH_READ, new RuntimeException("bluetooth read stream fail!"));                        }                    }                    break;                case READ_OPEN:                    isOpen.set(true);                    synchronized (this){                        notify();                    }                    sendEmptyMessage(READ);                    break;                case READ_CLOSE:                    removeMessages(READ);                    isOpen.set(false);                    synchronized (this){                        notify();                    }                    break;            }        }        public void open(){            synchronized (this){                try {                    sendEmptyMessage(READ_OPEN);                    wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }        public void close(){            synchronized (this){                try {                    sendEmptyMessage(READ_CLOSE);                    wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    /**     * 蓝牙状态管理     */    private class BluetoothStatusHandler extends Handler{        private int BBSmsg; //连接流程控制        BluetoothStatusHandler(Looper looper){            super(looper);        }        @Override        public void handleMessage(Message msg) {            int what = msg.what;            switch (what){                case MSG_BLUETOOTH_START:                    closeBluetoothDeviceHandler();                    boolean openSucess = openBluetoothDeviceHandler();                    if(openSucess){                        BBSmsg = MSG_BLUETOOTH_START; //设置状态为蓝牙打开                        bluetoothStatusChangeHandler(STATUS_BLUETOOTH_OPEN, "bluetooth opend!");                        sendEmptyMessage(MSG_BLUETOOTH_LISTEN);                    }else {                        bluetoothErrorHandler(ERROR_BLUETOOTH_UNABLE, new RuntimeException("bluetooth unable!"));                    }                    break;                case MSG_BLUETOOTH_LISTEN:                    if(BBSmsg == MSG_BLUETOOTH_START){                        BBSmsg = MSG_BLUETOOTH_LISTEN;                        acceptBluetoothConnectHandler();                        bluetoothStatusChangeHandler(STATUS_BLUETOOTH_SERVICE_ACCEPTED, "bluetooth service accepted!");                    }else {                        LogUtils.bluetooth("status error no handle:" + BBSmsg);                    }                    break;                case MSG_BLUETOOTH_CONNECTED:                    if(BBSmsg == MSG_BLUETOOTH_LISTEN){                        Object socket = msg.obj;                        if (socket != null) {                            closeBluetoothDeviceHandler();                            mConnectedHandler = new ConnectedHandler((BluetoothSocket) socket);                            if (mConnectedHandler.connectedSuccess()) {                                    //打开读数据                                mBluetoothReadHandler.open();                                BBSmsg = MSG_BLUETOOTH_CONNECTED;                                bluetoothStatusChangeHandler(STATUS_BLUETOOTH_CONNECTED, "bluetooth build connect!");                            } else {                                bluetoothErrorHandler(ERROR_BLUETOOTH_CONNECT, new RuntimeException("bluetooth service build error!"));                            }                        } else {                            bluetoothErrorHandler(ERROR_BLUETOOTH_CONNECT, new RuntimeException("bluetooth service build error!"));                        }                    }else {                        LogUtils.bluetooth("status error no handle:" + BBSmsg);                    }                    break;                case MSG_BLUETOOTH_CLOSE:                    BBSmsg = MSG_BLUETOOTH_CLOSE;                    closeBluetoothDeviceHandler();                    bluetoothStatusChangeHandler(STATUS_BLUETOOTH_CLOSE, "bluetooth close!");                    break;                default:                    break;            }        }    }    /**     * 发送打开蓝牙命令     */    public void open(){        LogUtils.bluetooth("open");        mBluetoothStatusHandler.sendEmptyMessage(MSG_BLUETOOTH_START);    }    /**     * 发送关闭蓝牙命令     */    public void close(){        LogUtils.bluetooth("close");        mBluetoothStatusHandler.sendEmptyMessage(MSG_BLUETOOTH_CLOSE);    }    //private 检查蓝牙状态并打开蓝牙,整体检查返回状态    private boolean openBluetoothDeviceHandler() {        if (mBluetoothAdapter == null) {            //蓝牙模块不可用            return false;        }        //确保蓝牙打开        if (!mBluetoothAdapter.isEnabled()) {            mBluetoothAdapter.enable();            int MAX_COUNT = 10;            int tryCount = 0;            boolean enable = false;            while(!enable){                //检查是否打开完成                enable = mBluetoothAdapter.isEnabled();                if(tryCount > MAX_COUNT){                    return false;                }                try {                    tryCount++;                    Thread.sleep(500);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }        return true;    }    /**     * private 关闭蓝牙,整体检查返回状态     */    private void closeBluetoothDeviceHandler() {        //关闭读数据        mBluetoothReadHandler.close();        if (mConnectedHandler != null) {            mConnectedHandler.cancel();            mConnectedHandler = null;        }        if (mAcceptManagerThread != null) {            mAcceptManagerThread.cancel();            mAcceptManagerThread = null;        }    }    private static final String NAME_SECURE = "BluetoothChatSecure";    private static final String NAME_INSECURE = "BluetoothChatInsecure";    private static final UUID MY_UUID_SECURE = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");    private static final UUID MY_UUID_INSECURE = UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");    //private static final UUID MY_UUID_INSECURE = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");    private volatile ConnectedHandler mConnectedHandler;    /**     * private 进入蓝牙监听模式     * 开始启动监听模式     */    private void acceptBluetoothConnectHandler(){        closeBluetoothDeviceHandler();        mAcceptManagerThread = new AcceptManagerThread();        mAcceptManagerThread.start();    }    private AcceptManagerThread mAcceptManagerThread;    private class AcceptManagerThread extends Thread{        //private final AcceptThread mSecureAcceptThread;        private final AcceptThread mInsecureAcceptThread;        AcceptManagerThread(){            //mSecureAcceptThread = new AcceptThread(true);            mInsecureAcceptThread = new AcceptThread(false);        }        @Override        public void run() {            //Future f1 = pool.submit(mSecureAcceptThread);            Future f2 = pool.submit(mInsecureAcceptThread);            try {//                BluetoothSocket socket1 = f1.get();//                BluetoothSocket socket2 = f2.get();//                if(socket1 != null || socket2 != null){//                    //启动链接流程//                    Message message = Message.obtain();//                    if(f1.get() != null){//                        message.obj = f1.get();//                    }else {//                        message.obj = f2.get();//                    }//                    message.what = MSG_BLUETOOTH_CONNECTED;//                    mBluetoothStatusHandler.sendMessage(message);//                }else {//                    throw new RuntimeException("bluetooth service build error!");//                }                BluetoothSocket socket2 = f2.get();                if(socket2 != null){                    //启动链接流程                    Message message = Message.obtain();                    message.obj = f2.get();                    message.what = MSG_BLUETOOTH_CONNECTED;                    mBluetoothStatusHandler.sendMessage(message);                }else {                    throw new RuntimeException("bluetooth service build error!");                }            } catch (Exception e) {                e.printStackTrace();                bluetoothErrorHandler(ERROR_BLUETOOTH_SERVICE_ACCEPT, new RuntimeException("bluetooth service build error!"));            }        }        public void cancel() {            //mSecureAcceptThread.cancel();            mInsecureAcceptThread.cancel();        }    }    private static final ExecutorService pool = Executors.newFixedThreadPool(2);    private class AcceptThread implements Callable {        private final BluetoothServerSocket mmServerSocket;        private String mSocketType;        public AcceptThread(boolean secure) {            BluetoothServerSocket tmp = null;            mSocketType = secure ? "Secure" : "Insecure";            try {                if (secure) {                    tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE,                            MY_UUID_SECURE);                } else {                    tmp = mBluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(                            NAME_INSECURE, MY_UUID_INSECURE);                }            } catch (Exception e) {                e.printStackTrace();            }            mmServerSocket = tmp;        }        @Override        public BluetoothSocket call() throws Exception {            //进入监听状态            BluetoothSocket socket;            try {                if (mmServerSocket != null) {                    LogUtils.bluetooth("accept start");                    socket = mmServerSocket.accept();                    LogUtils.bluetooth("accept end");                } else {                    LogUtils.bluetooth("mmServerSocket = null");                    return null;                }            } catch (Exception e) {                e.printStackTrace();                LogUtils.bluetooth("accept error");                return null;            }            LogUtils.bluetooth("return:" + socket);            //取消            mAcceptManagerThread.cancel();            return socket;        }        public void cancel() {            LogUtils.bluetooth("Socket Type" + mSocketType + "cancel" + this);            try {                mmServerSocket.close();            } catch (Exception e) {                e.printStackTrace();                bluetoothErrorHandler(ERROR_BLUETOOTH_CLOSE, e);            }        }    }    private class ConnectedHandler {        private static final int READ_MAX = 256;        private final byte[] bytes = new byte[READ_MAX];        private final BluetoothSocket mmSocket;        private final InputStream mmInStream;        private final OutputStream mmOutStream;        private final String mmDevice;        public ConnectedHandler(BluetoothSocket socket) {            mmSocket = socket;            mmDevice = socket.getRemoteDevice().getName();            InputStream tmpIn = null;            OutputStream tmpOut = null;            try {                tmpIn = socket.getInputStream();                tmpOut = socket.getOutputStream();            } catch (Exception e) {                e.printStackTrace();            }            mmInStream = tmpIn;            mmOutStream = tmpOut;        }        public boolean connectedSuccess(){            return mmInStream != null && mmOutStream != null;        }        public void read() throws Exception {            int readCount = mmInStream.read(bytes);            if(onPushListener != null){                byte[] datas = new byte[readCount];                System.arraycopy(bytes, 0, datas, 0, readCount);                onPushListener.onDecode(datas);            }        }        public void write(byte[] buffer) throws Exception {            mmOutStream.write(buffer);        }        public void cancel() {            try {                mmInStream.close();                mmOutStream.close();                mmSocket.close();            } catch (Exception e) {                e.printStackTrace();                bluetoothErrorHandler(ERROR_BLUETOOTH_CLOSE, e);            }        }        public String getMmDevice() {            return mmDevice;        }    }    /**     * 发送消息     */    public void write(byte[] out) {        try{           if (mConnectedHandler != null) {               mConnectedHandler.write(out);           }        }catch (Exception e){            e.printStackTrace();            bluetoothErrorHandler(ERROR_BLUETOOTH_WRITE, e);        }    }    /**     * 蓝牙状态变化     */    private static final int ERROR_BLUETOOTH_UNABLE = 2;            //蓝牙不可用异常    private static final int ERROR_BLUETOOTH_CLOSE = 3;             //蓝牙关闭异常    private static final int ERROR_BLUETOOTH_READ = 4;              //蓝牙读取异常    private static final int ERROR_BLUETOOTH_WRITE = 5;             //蓝牙写异常    private static final int ERROR_BLUETOOTH_CONNECT = 6;           //蓝牙连接异常    private static final int ERROR_BLUETOOTH_SERVICE_ACCEPT = 7;    //蓝牙服务建立异常    private static final int STATUS_BLUETOOTH_OPEN = 8;                     //蓝牙打开    private static final int STATUS_BLUETOOTH_SERVICE_ACCEPTED = 9;         //蓝牙服务建立    private static final int STATUS_BLUETOOTH_CONNECTED = 10;               //蓝牙连接建立    private static final int STATUS_BLUETOOTH_CLOSE = 11;                   //蓝牙关闭    private void bluetoothErrorHandler(int errorCount, Exception e){        switch (errorCount){            case ERROR_BLUETOOTH_UNABLE:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothUnableError(e);                }                break;            case ERROR_BLUETOOTH_SERVICE_ACCEPT:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothServiceAcceptError(e);                }                break;            case ERROR_BLUETOOTH_CONNECT:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothConnectError(e);                }                break;            case ERROR_BLUETOOTH_READ:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothReadError(e);                }                break;            case ERROR_BLUETOOTH_WRITE:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothWriteError(e);                }                break;            case ERROR_BLUETOOTH_CLOSE:                if(onBluetoothErrorListener != null){                    onBluetoothErrorListener.bluetoothCloseError(e);                }                break;            default:                break;        }    }    private void bluetoothStatusChangeHandler(int statusCount, String statusMessage){        LogUtils.bluetooth(statusMessage + "  status count:  " + statusCount);        switch (statusCount){            case STATUS_BLUETOOTH_OPEN:                if(onBluetoothStatusListener != null){                    //获取本机蓝牙信息                    String localAddress = mBluetoothAdapter.getAddress();                    String localName = mBluetoothAdapter.getName();                    LogUtils.bluetooth("local bluetooth message [address:" + localAddress + ",name:" + localName);                    onBluetoothStatusListener.bluetoothOpened(statusMessage, localAddress, localName);                }                break;            case STATUS_BLUETOOTH_SERVICE_ACCEPTED:                if(onBluetoothStatusListener != null){                    LogUtils.bluetooth("bluetooth accepted:");                    onBluetoothStatusListener.bluetoothAccepted(statusMessage);                }                break;            case STATUS_BLUETOOTH_CONNECTED:                if(onBluetoothStatusListener != null){                    LogUtils.bluetooth("bluetooth connected:" + mConnectedHandler.getMmDevice());                    onBluetoothStatusListener.bluetoothConnected(mConnectedHandler.getMmDevice());                }                break;            case STATUS_BLUETOOTH_CLOSE:                if(onBluetoothStatusListener != null){                    onBluetoothStatusListener.bluetoothClosed(statusMessage);                }                break;            default:                break;        }    }    public void setOnBluetoothErrorListener(OnBluetoothErrorListener onBluetoothErrorListener) {        this.onBluetoothErrorListener = onBluetoothErrorListener;    }    private volatile OnBluetoothErrorListener onBluetoothErrorListener;    interface OnBluetoothErrorListener{        void bluetoothUnableError(Exception e);        void bluetoothServiceAcceptError(Exception e);        void bluetoothConnectError(Exception e);        void bluetoothReadError(Exception e);        void bluetoothWriteError(Exception e);        void bluetoothCloseError(Exception e);    }    public void setOnBluetoothStatusListener(OnBluetoothStatusListener onBluetoothStatusListener) {        this.onBluetoothStatusListener = onBluetoothStatusListener;    }    private volatile OnBluetoothStatusListener onBluetoothStatusListener;    interface OnBluetoothStatusListener {        void bluetoothOpened(String message, String localAddress, String localName);        void bluetoothAccepted(String message);        void bluetoothConnected(String message);        void bluetoothClosed(String message);    }    public void setOnPushListener(OnPushListener onPushListener) {        this.onPushListener = onPushListener;    }    private volatile OnPushListener onPushListener;    interface OnPushListener{        void onDecode(byte[] datas);    }}

package com.ibrobo.robotbingo.common.bluetooth.service;import com.infrastructure.utils.LogUtils;/** * 蓝牙框架控制接口 */public class BBSCommander implements        BBS.OnPushListener,        BBS.OnBluetoothErrorListener,        BBS.OnBluetoothStatusListener{    private static final BBS BBS = new BBS();    @Override    public void bluetoothOpened(String message, String localAddress, String localName) {        LogUtils.bluetooth("bluetooth open!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothOpened(message);        }    }    @Override    public void bluetoothAccepted(String message) {        LogUtils.bluetooth("bluetooth bluetoothAccepted!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothAccepted(message);        }    }    @Override    public void bluetoothConnected(String device) {        LogUtils.bluetooth("bluetooth connected!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothConnected(device);        }    }    @Override    public void bluetoothClosed(String message) {        LogUtils.bluetooth("bluetooth close!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothClosed(message);        }    }    @Override    public void bluetoothServiceAcceptError(Exception error) {        LogUtils.bluetooth(error + "bluetooth service build error!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothError(error);        }        BBS.open();    }    @Override    public void bluetoothConnectError(Exception error) {        LogUtils.bluetooth(error + "bluetooth connect error!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothError(error);        }        BBS.open();    }    @Override    public void bluetoothReadError(Exception error) {        LogUtils.bluetooth(error + "bluetooth read error!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothError(error);        }        BBS.open();    }    @Override    public void bluetoothWriteError(Exception error) {        LogUtils.bluetooth(error + "bluetooth write error!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothError(error);        }        BBS.open();    }    @Override    public void bluetoothUnableError(Exception error) {        LogUtils.bluetooth("bluetooth unable!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothUnable(error);        }    }    @Override    public void bluetoothCloseError(Exception error) {        LogUtils.bluetooth("bluetooth close error!");        if(onBluetoothStatusChangeListener != null){            onBluetoothStatusChangeListener.bluetoothError(error);        }    }    @Override    public void onDecode(byte[] datas) {        if(mOnDecoder != null){            mOnDecoder.onDecode(datas);        }    }    private static class SingletonInstance {        private static final BBSCommander mInstance = new BBSCommander();    }    public static BBSCommander getInstance(){        return SingletonInstance.mInstance;    }    public void init(){        BBS.setOnBluetoothStatusListener(this);        BBS.setOnBluetoothErrorListener(this);        BBS.setOnPushListener(this);    }    public void open(){        BBS.open();    }    public void close(){        BBS.close();    }    public void write(byte[] bytes){        BBS.write(bytes);    }    public void setOnBluetoothStatusChangeListener(OnBluetoothStatusChangeListener onBluetoothStatusChangeListener) {        this.onBluetoothStatusChangeListener = onBluetoothStatusChangeListener;    }    private volatile OnBluetoothStatusChangeListener onBluetoothStatusChangeListener;    public interface OnBluetoothStatusChangeListener{        void bluetoothUnable(Exception message);        void bluetoothError(Exception error);        void bluetoothOpened(String message);        void bluetoothAccepted(String message);        void bluetoothConnected(String message);        void bluetoothClosed(String message);    }    private volatile OnDecoder mOnDecoder;    public void setOnDecoder(OnDecoder mOnDecoder) {        this.mOnDecoder = mOnDecoder;    }    public interface OnDecoder {        void onDecode(byte[] bytes);    }}

更多相关文章

随机推荐