Android-蓝牙通信

设备:客户端:小米8 Android 9.0,服务端:小米5 Android8.0

蓝牙通信步骤:【搜索,配对,连接,通信】

目录

一、蓝牙搜索功能的实现

1.判断设备是否支持蓝牙,取得蓝牙适配器:bluetoothAdapter

2.打开蓝牙:

3.搜索蓝牙

二、蓝牙配对功能的实现

三、蓝牙连接功能的实现

四、蓝牙通信功能的实现

 五、AndroidManifest.xml


一、蓝牙搜索功能的实现

1.判断设备是否支持蓝牙,取得蓝牙适配器:bluetoothAdapter

private BluetoothAdapter bluetoothAdapter; //蓝牙适配器BluetoothAdapter

/**
 * 判断是否设备是否支持蓝牙
 * @return 是否支持
 */
private boolean isSupported(){
    //初始化
    bluetoothAdapter =  BluetoothAdapter.getDefaultAdapter();

    if (bluetoothAdapter == null){
        Log.i(TAG, "isSupported: 设备不支持蓝牙");
        return false;
    }else{
        return true;
    }
}

2.打开蓝牙:

    1、判断蓝牙是否打开:bluetoothAdapter.isEnabled();

          需要在 AndroidManifest.xml 中添加 android.permission.BLUETOOTH 权限

    2、判断Android版本,现在版本高了需要在activity中添加动态权限,否则搜索时 无法发现蓝牙设备   。

         也需在AndroidManifest.xml 添加 android.permission.ACCESS_FINE_LOCATIONACCESS_COARSE_LOCATION权限

    3、打开蓝牙设备:bluetoothAdapter.enable();

          需要在 AndroidManifest.xml 中添加 android.permission.BLUETOOTH_ADMIN 权限

//判断蓝牙是否打开:bluetoothAdapter.isEnabled()
//Missing permissions required by BluetoothAdapter.isEnabled: android.permission.BLUETOOTH
//出现这个是因为没有在 AndroidManifest.xml 中添加权限
if(bluetoothAdapter.isEnabled()){
    //已经打开蓝牙,判断Android版本是否需要添加权限,解决:无法发现蓝牙设备的问题
    getPermission();
}else{
    //开启蓝牙
    bluetoothAdapter.enable();
    //关闭蓝牙:bluetoothAdapter.disable();
}
/**
 * 动态权限
 *
 * 解决:无法发现蓝牙设备的问题
 *
 * 对于发现新设备这个功能, 还需另外两个权限(Android M 以上版本需要显式获取授权,附授权代码):
 */
private final int ACCESS_LOCATION=1;
@SuppressLint("WrongConstant")
private void getPermission() {
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
        int permissionCheck = 0;
        permissionCheck = this.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION);
        permissionCheck += this.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION);

        if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
            //未获得权限
            this.requestPermissions( // 请求授权
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION,
                            Manifest.permission.ACCESS_COARSE_LOCATION},
                    ACCESS_LOCATION);// 自定义常量,任意整型
        }
    }
}

/**
 * 请求权限的结果回调。每次调用 requestpermissions(string[],int)时都会调用此方法。
 * @param requestCode 传入的请求代码
 * @param permissions 传入permissions的要求
 * @param grantResults 相应权限的授予结果:PERMISSION_GRANTED 或 PERMISSION_DENIED
 */
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    switch (requestCode) {
        case ACCESS_LOCATION:
            if (hasAllPermissionGranted(grantResults)) {
                Log.i(TAG, "onRequestPermissionsResult: 用户允许权限");
            } else {
                Log.i(TAG, "onRequestPermissionsResult: 拒绝搜索设备权限");
            }
            break;
    }
}

private boolean hasAllPermissionGranted(int[] grantResults) {
    for (int grantResult : grantResults) {
        if (grantResult == PackageManager.PERMISSION_DENIED) {
            return false;
        }
    }
    return true;
}

Android-蓝牙通信_第1张图片    Android-蓝牙通信_第2张图片    Android-蓝牙通信_第3张图片

3.搜索蓝牙

    1、在当前activity的 onStart() 中注册广播

    2、按钮点击进行搜索设备

    3、写一个广播来接收查询到的设备数据

    4、在当前activity的 onStop() 中取消广播

/**
 * 1.在当前activity的 onStart() 中注册广播
 */
@Override
protected void onStart() {
    super.onStart();
    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);//创建一个查找蓝牙设备的广播意图
    filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);// 创建一个结束查找蓝牙设备结束的广播意图

    //注册一个广播接收者,开启查找蓝牙设备意图后将结果以广播的形式返回
    this.registerReceiver(mReceiver, filter);
}

/**
 * 2. 按钮点击进行搜索设备的方法
 *
 * 搜索未配对的设备
 */
private void SearchDevices(){
    //判断是否正在搜索
    if (bluetoothAdapter.isDiscovering()) {
        //如果正在搜索则取消搜索后再搜索
        bluetoothAdapter.cancelDiscovery();
    }
    // 开始搜索蓝牙设备,搜索到的蓝牙设备通过广播接受者返回
    boolean startDiscovery= bluetoothAdapter.startDiscovery();

    if(startDiscovery){
        //开始搜索:
        // 清空之前的记录
        devicesUnpaired.clear();
        nameUnpaired.clear();
    }
}

//存放未配对的蓝牙设备
ArrayList devicesUnpaired=new ArrayList<>();
//存放未配对的蓝牙设备的名称或地址【方便ListView中展示】
ArrayList nameUnpaired=new ArrayList<>();

/**
 * 3. 写一个广播来接收查询到的设备数据
 *      BroadcastReceiver 广播接收者
 *      BluetoothDevice 蓝牙设备
 */
private final BroadcastReceiver mReceiver = new BroadcastReceiver(){
    public void onReceive(Context context, Intent intent){
        String action = intent.getAction();
        BluetoothDevice device;
        switch (action) {
            case BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
                Log.i(TAG, "ACTION_DISCOVERY_FINISHED: 搜索完毕");
                showToast("搜索完毕");
                break;
            case BluetoothDevice.ACTION_FOUND:
                Log.i(TAG, "ACTION_FOUND: 正在搜索设备...");
                device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);//搜索到的蓝牙设备【未配对+已配对】

                //取得未配对设备集合
                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                    showToast(device.getName()==null?device.getAddress():device.getName());

                    devicesUnpaired.add(device);
                    nameUnpaired.add(device.getName()==null?device.getAddress():device.getName());
                }
                break;
        }
    }
};

/**
 * 4. 取消注册广播
 */
@Override
protected void onStop() {
    super.onStop();
    this.unregisterReceiver(mReceiver);
}

Android-蓝牙通信_第4张图片    Android-蓝牙通信_第5张图片

二、蓝牙配对功能的实现

该方法会弹出蓝牙配对确认框

//【手动配对】会弹出 配对确认框
private void unpairedDevicesList(){
    //viewUnpaired:是listView。nameUnpaire:是之前取得的未配对的蓝牙名称。devicesUnpaired:是之前取得的未配对的蓝牙设备
    ArrayAdapter adapter = new ArrayAdapter(
            MainActivity.this, android.R.layout.simple_list_item_1, nameUnpaired);
    viewUnpaired.setAdapter(adapter);

    viewUnpaired.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView parent, View view, int position, long id) {
            try {
                BluetoothDevice device=devicesUnpaired.get((int) id);
                // 调用配对的方法,此方法是异步的,系统会触发BluetoothDevice.ACTION_PAIRING_REQUEST的广播
                // 收到此广播后,设置配对的密码
                Method createBondMethod = device.getClass().getMethod("createBond");
                createBondMethod.invoke(device);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

客户端:Android-蓝牙通信_第6张图片 服务端:Android-蓝牙通信_第7张图片 结果:Android-蓝牙通信_第8张图片

三、蓝牙连接功能的实现

取的已配对的设备进行连接:

     1、网上有个建立和管理蓝牙连接的工具类:BluetoothChatUtil.java

     2、取得已配对设备列表,选择设备进行连接

     3、在onCreate中获取实例BluetoothChatUtil,且注册Handler

     4、写Handler

工具类:BluetoothChatUtil.java

/**
 *该类的工作:建立和管理蓝牙连接。
 *共有三个线程。mAcceptThread线程用来监听socket连接(服务端使用).
 *mConnectThread线程用来连接serversocket(客户端使用)。
 *mConnectedThread线程用来处理socket发送、接收数据。(客户端和服务端共用)
 */
public class BluetoothChatUtil {
    private static final String TAG = "BluetoothChatClient";
    private static final boolean D = true;

    // 服务名 SDP
    private static final String SERVICE_NAME = "BluetoothChat";
    // uuid SDP
    private static final UUID SERVICE_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    // 蓝牙适配器
    private final BluetoothAdapter mAdapter;
    private Handler mHandler;
    private AcceptThread mAcceptThread;

    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;

    private int mState;
    private static BluetoothChatUtil mBluetoothChatUtil;
    private BluetoothDevice mConnectedBluetoothDevice;
    //常数,指示当前的连接状态
    public static final int STATE_NONE = 0;       // 当前没有可用的连接
    public static final int STATE_LISTEN = 1;     // 现在侦听传入的连接
    public static final int STATE_CONNECTING = 2; // 现在开始连接
    public static final int STATE_CONNECTED = 3;  // 现在连接到远程设备
    public static final int STATAE_CONNECT_FAILURE = 4; //连接失败
    public static final int MESSAGE_DISCONNECTED = 5;   //断开连接
    public static final int STATE_CHANGE = 6; //连接状态改变
    public static final int MESSAGE_READ = 7;
    public static final int MESSAGE_WRITE= 8;

    public static final String DEVICE_NAME = "device_name";
    public static final String READ_MSG = "read_msg";
    /**
     * 构造函数。准备一个新的bluetoothchat会话。
     * @param context
     */
    private BluetoothChatUtil(Context context) {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
    }

    public static BluetoothChatUtil getInstance(Context c){
        if(null == mBluetoothChatUtil){
            mBluetoothChatUtil = new BluetoothChatUtil(c);
        }
        return mBluetoothChatUtil;
    }
    public void registerHandler(Handler handler){
        mHandler = handler;
    }

    public void unregisterHandler(){
        mHandler = null;
    }
    /**
     * 设置当前状态的聊天连接
     * @param state  整数定义当前连接状态
     */
    private synchronized void setState(int state) {
        if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
        mState = state;
        // 给新状态的处理程序,界面活性可以更新
        mHandler.obtainMessage(STATE_CHANGE, state, -1).sendToTarget();
    }

    /**
     * 返回当前的连接状态。 */
    public synchronized int getState() {
        return mState;
    }

    public BluetoothDevice getConnectedDevice(){
        return mConnectedBluetoothDevice;
    }
    /**
     * 开始聊天服务。特别acceptthread开始
     * 开始服务器模式。 */
    public synchronized void startListen() {
        if (D) Log.d(TAG, "start");
        // 取消任何线程正在运行的连接
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
        // 启动线程来监听一个bluetoothserversocket
        if (mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
        }
        setState(STATE_LISTEN);
    }

    /**
     * 开始connectthread启动连接到远程设备。
     * @param device 连接的蓝牙设备
     */
    public synchronized void connect(BluetoothDevice device) {
        if (D) Log.d(TAG, "connect to: " + device);
        // 取消任何线程试图建立连接
        if (mState == STATE_CONNECTING) {
            if (mConnectThread != null) {
                mConnectThread.cancel();
                mConnectThread = null;
            }
        }
        // 取消任何线程正在运行的连接
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        //启动线程连接到远程设备
        mConnectThread = new ConnectThread(device);
        mConnectThread.start();
        setState(STATE_CONNECTING);
    }

    /**
     * 开始ConnectedThread开始管理一个蓝牙连接,传输、接收数据.
     * @param socket socket连接
     * @param device 已连接的蓝牙设备
     */
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        if (D) Log.d(TAG, "connected");
        //取消任何线程正在运行的连接
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
        // 启动线程管理连接和传输
        mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        //把连接设备的名字传到 ui Activity
        mConnectedBluetoothDevice =  device;
        Message msg = mHandler.obtainMessage(STATE_CONNECTED);
        Bundle bundle = new Bundle();
        bundle.putString(DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
        setState(STATE_CONNECTED);
    }

    /**
     * 停止所有的线程
     */
    public synchronized void disconnect() {
        if (D) Log.d(TAG, "disconnect");
        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
        if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
        setState(STATE_NONE);
    }

    /**
     * Write to the ConnectedThread in an unsynchronized manner
     * @param out The bytes to write
     * @see ConnectedThread#write(byte[])
     */
    public void write(byte[] out) {
        //创建临时对象
        ConnectedThread r;
        // 同步副本的connectedthread
        synchronized (this) {
            if (mState != STATE_CONNECTED) return;
            r = mConnectedThread;
        }
        // 执行写同步
        r.write(out);
    }



    /**
     * Indicate that the connection attempt failed and notify the UI Activity.
     */
    private void connectionFailed() {
        // 发送失败的信息带回活动
        Message msg = mHandler.obtainMessage(STATAE_CONNECT_FAILURE);
        mHandler.sendMessage(msg);
        mConnectedBluetoothDevice = null;
        setState(STATE_NONE);
    }

    /**
     * Indicate that the connection was lost and notify the UI Activity.
     */
    public void connectionLost() {
        // 发送失败的信息带回Activity
        Message msg = mHandler.obtainMessage(MESSAGE_DISCONNECTED);
        mHandler.sendMessage(msg);
        mConnectedBluetoothDevice = null;
        setState(STATE_NONE);
    }

    /**
     *本线程 侦听传入的连接。
     *它运行直到连接被接受(或取消)。
     */
    private class AcceptThread extends Thread {
        // 本地服务器套接字
        private final BluetoothServerSocket mServerSocket;
        public AcceptThread() {
            BluetoothServerSocket tmp = null;
            // 创建一个新的侦听服务器套接字
            try {
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(
                        SERVICE_NAME, SERVICE_UUID);
                //tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(SERVICE_NAME, SERVICE_UUID);
            } catch (IOException e) {
                Log.e(TAG, "listen() failed", e);
            }
            mServerSocket = tmp;
        }

        public void run() {
            if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;
            // 循环,直到连接成功
            while (mState != STATE_CONNECTED) {
                try {
                    // 这是一个阻塞调用 返回成功的连接
                    // mServerSocket.close()在另一个线程中调用,可以中止该阻塞
                    socket = mServerSocket.accept();
                } catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }
                // 如果连接被接受
                if (socket != null) {
                    synchronized (BluetoothChatUtil.this) {
                        switch (mState) {
                            case STATE_LISTEN:
                            case STATE_CONNECTING:
                                // 正常情况。启动ConnectedThread。
                                connected(socket, socket.getRemoteDevice());
                                break;
                            case STATE_NONE:
                            case STATE_CONNECTED:
                                // 没有准备或已连接。新连接终止。
                                try {
                                    socket.close();
                                } catch (IOException e) {
                                    Log.e(TAG, "Could not close unwanted socket", e);
                                }
                                break;
                        }
                    }
                }
            }
            if (D) Log.i(TAG, "END mAcceptThread");
        }

        public void cancel() {
            if (D) Log.d(TAG, "cancel " + this);
            try {
                mServerSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of server failed", e);
            }
        }
    }


    /**
     * 本线程用来连接设备
     *
     */
    private class ConnectThread extends Thread {
        private BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;
            // 得到一个bluetoothsocket
            try {
                mmSocket = device.createRfcommSocketToServiceRecord
                        (SERVICE_UUID);
            } catch (IOException e) {
                Log.e(TAG, "create() failed", e);
                mmSocket = null;
            }
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread");
            try {
                // socket 连接,该调用会阻塞,直到连接成功或失败
                mmSocket.connect();
            } catch (IOException e) {
                Log.e(TAG, "IOException");
                connectionFailed();
                try {//关闭这个socket
                    mmSocket.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                return;
            }
            // 启动连接线程
            connected(mmSocket, mmDevice);
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

    /**
     * 本线程server 和client共用.
     * 它处理所有传入和传出的数据。
     */
    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            Log.d(TAG, "create ConnectedThread");
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;
            // 获得bluetoothsocket输入输出流
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "没有创建临时sockets", e);
            }
            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            // 监听输入流
            while (true) {
                try {
                    byte[] buffer = new byte[512];
                    // 读取输入流
                    int bytes = mmInStream.read(buffer);
                    // 发送获得的字节的ui activity
                    Message msg = mHandler.obtainMessage(MESSAGE_READ);
                    Bundle bundle = new Bundle();
                    bundle.putByteArray(READ_MSG, buffer);
                    msg.setData(bundle);
                    mHandler.sendMessage(msg);
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        /**
         * 向外发送。
         * @param buffer  发送的数据
         */
        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);
                // 分享发送的信息到Activity
                mHandler.obtainMessage(MESSAGE_WRITE, -1, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

    public static int ByteArrayToInt(byte b[]) throws Exception {
        ByteArrayInputStream buf = new ByteArrayInputStream(b);
        DataInputStream dis = new DataInputStream(buf);
        return dis.readInt();
    }
}

【客户端】

private BluetoothChatUtil mBlthChatUtil;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mBlthChatUtil = BluetoothChatUtil.getInstance(this);
    mBlthChatUtil.registerHandler(mHandler);
}


//存放已配对的蓝牙设备
ArrayList devicesPaired=new ArrayList<>();
/**
 * 我这的方法是:
 *  取得已经配对的蓝牙设备的 名称或者地址 显示在listView中
 *  且listView的选项设置点击事件,以便进行设备连接
 */
private void PairedDevicesList(){
    //已配对设备集合
    Set pairedDevices = bluetoothAdapter.getBondedDevices();

    //listView需要string类型,所以提取名称或者地址以方便展示
    ArrayList mArrayAdapter = new ArrayList<>();
    if(pairedDevices.size() > 0){
        //如果有配对的设备
        for(BluetoothDevice device : pairedDevices){
            //通过array adapter在列表中添加设备名称和地址
            if(device.getName()==null){
                mArrayAdapter.add(device.getAddress());
            }else{
                mArrayAdapter.add(device.getName());
            }
            devicesPaired.add(device);
        }
    }else{
        mArrayAdapter.add("暂无已配对设备");
    }

    //将已配对的设备添加到listView中
    ArrayAdapter adapter = new ArrayAdapter(
            MainActivity.this, android.R.layout.simple_list_item_1, mArrayAdapter);
    viewPaired.setAdapter(adapter);

    viewPaired.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView parent, View view, int position, long id) {
            BluetoothDevice device=devicesPaired.get((int) id);
            if (bluetoothAdapter.isDiscovering()) {
                //取消搜索
                bluetoothAdapter.cancelDiscovery();
            }
            if (mBlthChatUtil.getState() == BluetoothChatUtil.STATE_CONNECTED) {
                Toast.makeText(MainActivity.this, "蓝牙已连接!!!!!!!", Toast.LENGTH_SHORT).show();
            }else {
                mBlthChatUtil.connect(device);
            }
        }
    });
}

private Handler mHandler = new Handler(){
    public void handleMessage(Message msg) {
        String deviceName = msg.getData().getString(BluetoothChatUtil.DEVICE_NAME);
        switch(msg.what){
            case BluetoothChatUtil.STATE_CONNECTED:
                showToast("连接成功");
                break;
            case BluetoothChatUtil.STATAE_CONNECT_FAILURE:
                showToast("连接失败");
                break;
            case BluetoothChatUtil.STATE_CHANGE:
                showToast("正在连接设备..");
                break;
            case BluetoothChatUtil.MESSAGE_DISCONNECTED:
                showToast("与设备断开连接");
                break;
            //读到另一方传送的消息
            case BluetoothChatUtil.MESSAGE_READ:{
                byte[] buf = msg.getData().getByteArray(BluetoothChatUtil.READ_MSG);
                String str = new String(buf,0,buf.length);
                Toast.makeText(getApplicationContext(), "读成功" + str, Toast.LENGTH_SHORT).show();
                break;
            }
            //发送消息给另一方
            case BluetoothChatUtil.MESSAGE_WRITE:{
                byte[] buf = (byte[]) msg.obj;
                String str = new String(buf,0,buf.length);
                Toast.makeText(getApplicationContext(), "发送成功" + str, Toast.LENGTH_SHORT).show();
                break;
            }
            default:
                break;
        }
    };
};
//toast提示
public void showToast(String msg){
    Toast.makeText(this,msg,Toast.LENGTH_SHORT).show();
}

【服务端】:就比客户端多了一项启动监听

/**
 * 活动和用户进行交互时调用【服务端】
 */
@Override
protected void onResume() {
    super.onResume();
    if (mBlthChatUtil != null) {
        if (mBlthChatUtil.getState() == BluetoothChatUtil.STATE_NONE) {
            // 启动蓝牙聊天服务
            mBlthChatUtil.startListen();
        }else if (mBlthChatUtil.getState() == BluetoothChatUtil.STATE_CONNECTED){
            BluetoothDevice device = mBlthChatUtil.getConnectedDevice();
            if(null != device && null != device.getName()){
                showToast("已成功连接到设备" + device.getName());
            }else {;
                showToast("未连接到设备");
            }
        }
    }
}

客户端:Android-蓝牙通信_第9张图片服务端:Android-蓝牙通信_第10张图片

四、蓝牙通信功能的实现

//调用write写需要发送的数据就行 
mBlthChatUtil.write("openIR#".getBytes());
//在mHandler方法中,接收方可对数据进行处理

 五、AndroidManifest.xml




     

     
    

     

    

    
        
            
                

                
            
        
    

好了简单记录一下

Dome源码:https://github.com/van9420/android-BluetoothDome

你可能感兴趣的:(Android,#蓝牙)