安卓蓝牙实现即时通讯功能

Posted 2020-07-07 benhuo931115

安卓蓝牙实现即时通讯功能

本demo是《android智能穿戴设备开发指南》书中的一块内容，实现了两台手机基于蓝牙进行即时通讯的功能。

demo演示如下:

结构图

主要代码

MainActivity：启动服务器和客户端界面

    @Override
    public void onClick(View arg0) {
        switch (arg0.getId()) {

            case R.id.startServerBtn:
                //打开服务器
                Intent serverIntent = new Intent(MainActivity.this, ServerActivity.class);
                serverIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(serverIntent);
                break;

            case R.id.startClientBtn:
                //打开客户端
                Intent clientIntent = new Intent(MainActivity.this, ClientActivity.class);
                clientIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(clientIntent);
                break;
        }
    }

ClientActivity

• 注册广播，开启服务（BluetoothClientService）

  //广播接收器
  private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
  
      @Override
      public void onReceive(Context context, Intent intent) {
          String action = intent.getAction();
  
          if (BluetoothTools.ACTION_NOT_FOUND_SERVER.equals(action)) {
              //未发现设备
              serversText.append("not found device\\r\\n");
  
          } else if (BluetoothTools.ACTION_FOUND_DEVICE.equals(action)) {
              //获取到设备对象
              BluetoothDevice device = (BluetoothDevice)intent.getExtras().get(BluetoothTools.DEVICE);
              deviceList.add(device);
              serversText.append(device.getName() + "\\r\\n");
  
          } else if (BluetoothTools.ACTION_CONNECT_SUCCESS.equals(action)) {
              //连接成功
              serversText.append("连接成功");
              sendBtn.setEnabled(true);
  
          } else if (BluetoothTools.ACTION_DATA_TO_GAME.equals(action)) {
              //接收数据
              TransmitBean data = (TransmitBean)intent.getExtras().getSerializable(BluetoothTools.DATA);
              String msg = "from remote " + new Date().toLocaleString() + " :\\r\\n" + data.getMsg() + "\\r\\n";
              chatEditText.append(msg);
  
          }
      }
  };
  

#

    //注册BoradcasrReceiver
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothTools.ACTION_NOT_FOUND_SERVER);
    intentFilter.addAction(BluetoothTools.ACTION_FOUND_DEVICE);
    intentFilter.addAction(BluetoothTools.ACTION_DATA_TO_GAME);
    intentFilter.addAction(BluetoothTools.ACTION_CONNECT_SUCCESS);
    registerReceiver(broadcastReceiver, intentFilter);

#

    //开启后台service
    Intent startService = new Intent(ClientActivity.this, BluetoothClientService.class);
    startService(startService);

#

• 开始搜索蓝牙和连接第一个设备

  startSearchBtn.setOnClickListener(new OnClickListener() {
  
          @Override
          public void onClick(View v) {
              //开始搜索
              Intent startSearchIntent = new Intent(BluetoothTools.ACTION_START_DISCOVERY);
              sendBroadcast(startSearchIntent);
          }
      });
  
  selectDeviceBtn.setOnClickListener(new OnClickListener() {
  
          @Override
          public void onClick(View v) {
              //选择第一个设备
              Intent selectDeviceIntent = new Intent(BluetoothTools.ACTION_SELECTED_DEVICE);
              selectDeviceIntent.putExtra(BluetoothTools.DEVICE, deviceList.get(0));
              sendBroadcast(selectDeviceIntent);
          }
      }); 
  

• 向服务器发送消息

  sendBtn.setOnClickListener(new OnClickListener() {
  
      @Override
      public void onClick(View v) {
          //发送消息
          if ("".equals(sendEditText.getText().toString().trim())) {
              Toast.makeText(ClientActivity.this, "输入不能为空", Toast.LENGTH_SHORT).show();
          } else {
              //发送消息
              TransmitBean data = new TransmitBean();
              data.setMsg(sendEditText.getText().toString());
              Intent sendDataIntent = new Intent(BluetoothTools.ACTION_DATA_TO_SERVICE);
              sendDataIntent.putExtra(BluetoothTools.DATA, data);
              sendBroadcast(sendDataIntent);
          }
      }
  });
  

ServerActivity

• 注册广播接收器

  //广播接收器
  private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
  
      @Override
      public void onReceive(Context context, Intent intent) {
  
          String action = intent.getAction();
  
          if (BluetoothTools.ACTION_DATA_TO_GAME.equals(action)) {
              //接收数据
              TransmitBean data = (TransmitBean) intent.getExtras().getSerializable(BluetoothTools.DATA);
              String msg = "from remote " + new Date().toLocaleString() + " :\\r\\n" + data.getMsg() + "\\r\\n";
              msgEditText.append(msg);
  
          } else if (BluetoothTools.ACTION_CONNECT_SUCCESS.equals(action)) {
              //连接成功
              serverStateTextView.setText("连接成功");
              sendBtn.setEnabled(true);
          }
  
      }
  };
  
  
  //注册BoradcasrReceiver
  IntentFilter intentFilter = new IntentFilter();
  intentFilter.addAction(BluetoothTools.ACTION_DATA_TO_GAME);
  intentFilter.addAction(BluetoothTools.ACTION_CONNECT_SUCCESS);
  
  registerReceiver(broadcastReceiver, intentFilter);
  

• 开启后台服务

  //开启后台service
  Intent startService = new Intent(ServerActivity.this, BluetoothServerService.class);
  startService(startService);
  

• 向客户端发送消息

  sendBtn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
          if ("".equals(sendMsgEditText.getText().toString().trim())) {
              Toast.makeText(ServerActivity.this, "输入不能为空", Toast.LENGTH_SHORT).show();
          } else {
              //发送消息
              TransmitBean data = new TransmitBean();
              data.setMsg(sendMsgEditText.getText().toString());
              Intent sendDataIntent = new Intent(BluetoothTools.ACTION_DATA_TO_SERVICE);
              sendDataIntent.putExtra(BluetoothTools.DATA, data);
              sendBroadcast(sendDataIntent);
          }
      }
  });
  

BluetoothClientService

    /**
     * 蓝牙模块客户端主控制Service
     */
    public class BluetoothClientService extends Service {

        //搜索到的远程设备集合
        private List<BluetoothDevice> discoveredDevices = new ArrayList<BluetoothDevice>();

        //蓝牙适配器
        private final BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        //蓝牙通讯线程
        private BluetoothCommunThread communThread;

        //控制信息广播的接收器
        private BroadcastReceiver controlReceiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();

                if (BluetoothTools.ACTION_START_DISCOVERY.equals(action)) {
                    //开始搜索
                    discoveredDevices.clear();  //清空存放设备的集合
                    bluetoothAdapter.enable();  //打开蓝牙
                    bluetoothAdapter.startDiscovery();  //开始搜索

                } else if (BluetoothTools.ACTION_SELECTED_DEVICE.equals(action)) {
                    //选择了连接的服务器设备
                    BluetoothDevice device = (BluetoothDevice)intent.getExtras().get(BluetoothTools.DEVICE);

                    //开启设备连接线程
                    new BluetoothClientConnThread(handler, device).start();

                } else if (BluetoothTools.ACTION_STOP_SERVICE.equals(action)) {
                    //停止后台服务
                    if (communThread != null) {
                        communThread.isRun = false;
                    }
                    stopSelf();

                } else if (BluetoothTools.ACTION_DATA_TO_SERVICE.equals(action)) {
                    //获取数据
                    Object data = intent.getSerializableExtra(BluetoothTools.DATA);
                    if (communThread != null) {
                        communThread.writeObject(data);
                    }

                }
            }
        };

        //蓝牙搜索广播的接收器
        private BroadcastReceiver discoveryReceiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                //获取广播的Action
                String action = intent.getAction();

                if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {
                    //开始搜索
                } else if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                    //发现远程蓝牙设备
                    //获取设备
                    BluetoothDevice bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    discoveredDevices.add(bluetoothDevice);

                    //发送发现设备广播
                    Intent deviceListIntent = new Intent(BluetoothTools.ACTION_FOUND_DEVICE);
                    deviceListIntent.putExtra(BluetoothTools.DEVICE, bluetoothDevice);
                    sendBroadcast(deviceListIntent);

                } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
                    //搜索结束
                    if (discoveredDevices.isEmpty()) {
                        //若未找到设备，则发动未发现设备广播
                        Intent foundIntent = new Intent(BluetoothTools.ACTION_NOT_FOUND_SERVER);
                        sendBroadcast(foundIntent);
                    }
                }
            }
        };

        //接收其他线程消息的Handler
        Handler handler = new Handler() {

            @Override
            public void handleMessage(Message msg) {
                //处理消息
                switch (msg.what) {
                    case BluetoothTools.MESSAGE_CONNECT_ERROR:
                        //连接错误
                        //发送连接错误广播
                        Intent errorIntent = new Intent(BluetoothTools.ACTION_CONNECT_ERROR);
                        sendBroadcast(errorIntent);
                        break;
                    case BluetoothTools.MESSAGE_CONNECT_SUCCESS:
                        //连接成功

                        //开启通讯线程
                        communThread = new BluetoothCommunThread(handler, (BluetoothSocket)msg.obj);
                        communThread.start();

                        //发送连接成功广播
                        Intent succIntent = new Intent(BluetoothTools.ACTION_CONNECT_SUCCESS);
                        sendBroadcast(succIntent);
                        break;
                    case BluetoothTools.MESSAGE_READ_OBJECT:
                        //读取到对象
                        //发送数据广播（包含数据对象）
                        Intent dataIntent = new Intent(BluetoothTools.ACTION_DATA_TO_GAME);
                        dataIntent.putExtra(BluetoothTools.DATA, (Serializable)msg.obj);
                        sendBroadcast(dataIntent);
                        break;
                }
                super.handleMessage(msg);
            }

        };

        /**
         * 获取通讯线程
         * @return
         */
        public BluetoothCommunThread getBluetoothCommunThread() {
            return communThread;
        }

        @Override
        public void onStart(Intent intent, int startId) {

            super.onStart(intent, startId);
        }

        @Override
        public IBinder onBind(Intent arg0) {
            return null;
        }

        /**
         * Service创建时的回调函数
         */
        @Override
        public void onCreate() {
            //discoveryReceiver的IntentFilter
            IntentFilter discoveryFilter = new IntentFilter();
            discoveryFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
            discoveryFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
            discoveryFilter.addAction(BluetoothDevice.ACTION_FOUND);

            //controlReceiver的IntentFilter
            IntentFilter controlFilter = new IntentFilter();
            controlFilter.addAction(BluetoothTools.ACTION_START_DISCOVERY);
            controlFilter.addAction(BluetoothTools.ACTION_SELECTED_DEVICE);
            controlFilter.addAction(BluetoothTools.ACTION_STOP_SERVICE);
            controlFilter.addAction(BluetoothTools.ACTION_DATA_TO_SERVICE);

            //注册BroadcastReceiver
            registerReceiver(discoveryReceiver, discoveryFilter);
            registerReceiver(controlReceiver, controlFilter);
            super.onCreate();
        }

        /**
         * Service销毁时的回调函数
         */
        @Override
        public void onDestroy() {
            if (communThread != null) {
                communThread.isRun = false;
            }
            //解除绑定
            unregisterReceiver(discoveryReceiver);
            super.onDestroy();
        }

    }

BluetoothServerService

    /**
     * 蓝牙模块服务器端主控制Service
     */
    public class BluetoothServerService extends Service {

        //蓝牙适配器
        private final BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        //蓝牙通讯线程
        private BluetoothCommunThread communThread;

        //控制信息广播接收器
        private BroadcastReceiver controlReceiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();

                if (BluetoothTools.ACTION_STOP_SERVICE.equals(action)) {
                    //停止后台服务
                    if (communThread != null) {
                        communThread.isRun = false;
                    }
                    stopSelf();

                } else if (BluetoothTools.ACTION_DATA_TO_SERVICE.equals(action)) {
                    //发送数据
                    Object data = intent.getSerializableExtra(BluetoothTools.DATA);
                    if (communThread != null) {
                        communThread.writeObject(data);
                    }

                }
            }
        };

        //接收其他线程消息的Handler
        private Handler serviceHandler = new Handler() {

            @Override
            public void handleMessage(Message msg) {

                switch (msg.what) {
                    case BluetoothTools.MESSAGE_CONNECT_SUCCESS:
                        //连接成功
                        //开启通讯线程
                        communThread = new BluetoothCommunThread(serviceHandler, (BluetoothSocket)msg.obj);
                        communThread.start();

                        //发送连接成功消息
                        Intent connSuccIntent = new Intent(BluetoothTools.ACTION_CONNECT_SUCCESS);
                        sendBroadcast(connSuccIntent);
                        break;

                    case BluetoothTools.MESSAGE_CONNECT_ERROR:
                        //连接错误
                        //发送连接错误广播
                        Intent errorIntent = new Intent(BluetoothTools.ACTION_CONNECT_ERROR);
                        sendBroadcast(errorIntent);
                        break;

                    case BluetoothTools.MESSAGE_READ_OBJECT:
                        //读取到数据
                        //发送数据广播（包含数据对象）
                        Intent dataIntent = new Intent(BluetoothTools.ACTION_DATA_TO_GAME);
                        dataIntent.putExtra(BluetoothTools.DATA, (Serializable)msg.obj);
                        sendBroadcast(dataIntent);

                        break;
                }

                super.handleMessage(msg);
            }

        };

        /**
         * 获取通讯线程
         * @return
         */
        public BluetoothCommunThread getBluetoothCommunThread() {
            return communThread;
        }

        @Override
        public void onCreate() {
            //ControlReceiver的IntentFilter
            IntentFilter controlFilter = new IntentFilter();
            controlFilter.addAction(BluetoothTools.ACTION_START_SERVER);
            controlFilter.addAction(BluetoothTools.ACTION_STOP_SERVICE);
            controlFilter.addAction(BluetoothTools.ACTION_DATA_TO_SERVICE);

            //注册BroadcastReceiver
            registerReceiver(controlReceiver, controlFilter);

            //开启服务器
            bluetoothAdapter.enable();  //打开蓝牙
            //开启蓝牙发现功能（300秒）
            Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
            discoveryIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
            discoveryIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(discoveryIntent);
            //开启后台连接线程
            new BluetoothServerConnThread(serviceHandler).start();

            super.onCreate();
        }

        @Override
        public void onDestroy() {
            if (communThread != null) {
                communThread.isRun = false;
            }
            unregisterReceiver(controlReceiver);
            super.onDestroy();
        }

        @Override
        public IBinder onBind(Intent arg0) {
            return null;
        }

    }

BluetoothClientConnThread

    /**
     * 蓝牙客户端连接线程
     */
    public class BluetoothClientConnThread extends Thread{

        private Handler serviceHandler;     //用于向客户端Service回传消息的handler
        private BluetoothDevice serverDevice;   //服务器设备
        private BluetoothSocket socket;     //通信Socket

        /**
         * 构造函数
         * @param handler
         * @param serverDevice
         */
        public BluetoothClientConnThread(Handler handler, BluetoothDevice serverDevice) {
            this.serviceHandler = handler;
            this.serverDevice = serverDevice;
        }

        @Override
        public void run() {
            BluetoothAdapter.getDefaultAdapter().cancelDiscovery();
            try {
                socket = serverDevice.createRfcommSocketToServiceRecord(BluetoothTools.PRIVATE_UUID);
                BluetoothAdapter.getDefaultAdapter().cancelDiscovery();
                socket.connect();

            } catch (Exception ex) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                //发送连接失败消息
                serviceHandler.obtainMessage(BluetoothTools.MESSAGE_CONNECT_ERROR).sendToTarget();
                return;
            }

            //发送连接成功消息，消息的obj参数为连接的socket
            Message msg = serviceHandler.obtainMessage();
            msg.what = BluetoothTools.MESSAGE_CONNECT_SUCCESS;
            msg.obj = socket;
            msg.sendToTarget();
        }
    }

BluetoothServerConnThread

    /**
     * 服务器连接线程
     */
    public class BluetoothServerConnThread extends Thread {

        private Handler serviceHandler;     //用于同Service通信的Handler
        private BluetoothAdapter adapter;
        private BluetoothSocket socket;     //用于通信的Socket
        private BluetoothServerSocket serverSocket;

        /**
         * 构造函数
         * @param handler
         */
        public BluetoothServerConnThread(Handler handler) {
            this.serviceHandler = handler;
            adapter = BluetoothAdapter.getDefaultAdapter();
        }

        @Override
        public void run() {

            try {
                serverSocket = adapter.listenUsingRfcommWithServiceRecord("Server", BluetoothTools.PRIVATE_UUID);
                socket = serverSocket.accept();
            } catch (Exception e) {
                //发送连接失败消息
                serviceHandler.obtainMessage(BluetoothTools.MESSAGE_CONNECT_ERROR).sendToTarget();
                e.printStackTrace();
                return;
            } finally {
                try {
                    serverSocket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (socket != null) {
                //发送连接成功消息，消息的obj字段为连接的socket
                Message msg = serviceHandler.obtainMessage();
                msg.what = BluetoothTools.MESSAGE_CONNECT_SUCCESS;
                msg.obj = socket;
                msg.sendToTarget();
            } else {
                //发送连接失败消息
                serviceHandler.obtainMessage(BluetoothTools.MESSAGE_CONNECT_ERROR).sendToTarget();
                return;
            }
        }
    }

BluetoothCommunThread

    /**
     * 蓝牙通讯线程
     */
    public class BluetoothCommunThread extends Thread {

        private Handler serviceHandler;        //与Service通信的Handler
        private BluetoothSocket socket;
        private ObjectInputStream inStream;        //对象输入流
        private ObjectOutputStream outStream;    //对象输出流
        public volatile boolean isRun = true;    //运行标志位

        /**
         * 构造函数
         *
         * @param handler 用于接收消息
         * @param socket
         */
        public BluetoothCommunThread(Handler handler, BluetoothSocket socket) {
            this.serviceHandler = handler;
            this.socket = socket;
            try {
                this.outStream = new ObjectOutputStream(socket.getOutputStream());
                this.inStream = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));
            } catch (Exception e) {
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                //发送连接失败消息
                serviceHandler.obtainMessage(BluetoothTools.MESSAGE_CONNECT_ERROR).sendToTarget();
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            while (true) {
                if (!isRun) {
                    break;
                }
                try {
                    Object obj = inStream.readObject();
                    //发送成功读取到对象的消息，消息的obj参数为读取到的对象
                    Message msg = serviceHandler.obtainMessage();
                    msg.what = BluetoothTools.MESSAGE_READ_OBJECT;
                    msg.obj = obj;
                    msg.sendToTarget();
                } catch (Exception ex) {
                    //发送连接失败消息
                    serviceHandler.obtainMessage(BluetoothTools.MESSAGE_CONNECT_ERROR).sendToTarget();
                    ex.printStackTrace();
                    return;
                }
            }

            //关闭流
            if (inStream != null) {
                try {
                    inStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outStream != null) {
                try {
                    outStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /**
         * 写入一个可序列化的对象
         *
         * @param obj
         */
        public void writeObject(Object obj) {
            try {
                outStream.flush();
                outStream.writeObject(obj);
                outStream.flush();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

• 最后还有一个蓝牙工具类（BluetoothTools）和用于传输的数据类（TransmitBean）代码就不粘了，直接把源码地址发出来

源码地址：
http://download.csdn.net/detail/benhuo931115/9519599