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

最新推荐文章于 2024-09-12 17:23:17 发布
最新推荐文章于 2024-09-12 17:23:17 发布
阅读量1.5w 收藏 27
点赞数 9
分类专栏： 穿戴App 文章标签： 即时通讯 蓝牙
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benhuo931115/article/details/51398681
版权

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

本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

benhuo931115
关注
专栏目录
Android蓝牙通信
12-09
Android蓝牙通信，连个手机直接通信，收发数据，界面简洁友好，代码易懂。使用的是虚拟串口通信，波特率9600，也可以和其他非手机端蓝牙设备通信，只要使用协议相同就行了。我的博客有说明http://blog.csdn.net/menghnhhuan/article/details/7057484
安卓蓝牙通讯
06-12
安卓蓝牙通讯 ,bluetooth,安卓，移动开发，安卓蓝牙通讯
构建基于蓝牙的实时聊天应用实战
weixin_42591413的博客
08-30 540
本文还有配套的精品资源，点击获取 简介：本项目介绍如何创建一个通过蓝牙技术实现实时通讯的聊天应用。该应用支持用户发现设备、建立连接、管理好友、发送接收消息以及用户界面交互等核心功能。同时，项目涵盖了蓝牙API使用、设备发现与配对、蓝牙连接、数据传输、好友管理、消息格式化与解析、错误处理、安全性、兼容性测试等技术要点。开发者通过这个项目可以学习和实践移动设备间无线通信的知识。...
Android学习笔记之蓝牙通信...
weixin_33941350的博客
07-27 210
PS：最近同学问我蓝牙的事，因此自己也就脑补了一下蓝牙...   学习内容： 1.如何实现蓝牙通信技术...     蓝牙通信其实是手机里很常用的一种通信方式，现在的手机中是必然存在蓝牙的，蓝牙通信也是有一部分优点的，功耗低，安全性比较高，但是缺点想必大家都知道，传输的速率也确实是不快，相比于Wifi通信，确实不值一提...虽然影响范围并不高，但是既然蓝牙存在，那么还是有必要知道蓝牙是如...
安卓BLE蓝牙通讯
最新发布
weixin_41119184的博客
09-12 1369
正常情况下，当触发触发onConnectSuccess回调时，设备已经连上的蓝牙的GATT，此时可认为蓝牙已连接，此时中心设备是无法和外围设备通讯的，还需根据蓝牙协议绑定指定的特征UUID，一般中心设备接收数据的为NOTIFY_CHARACTERISTIC_UUID，向外围设备发送消息的为WRITE_CHARACTERISTIC_UUID，大部分外设备还有描述符，例如接收数据需要的描述符NOTIFY_DESCRIPTOR_UUID等。断开设备后，进行重新扫描，再次连接时，可接收到Notify的消息。
蓝牙实现 即时通讯 传文件 详解读本
03-14
### 蓝牙实现即时通讯与文件传输详解 #### 一、基础知识介绍 在深入了解蓝牙技术如何实现即时通讯和文件传输之前，我们首先需要掌握一些基础概念，这将有助于我们更好地理解蓝牙的工作原理。 ##### 1. RFCOMM协议...
Android平台蓝牙即时通讯系统设计与实现
作者深入研究了Android蓝牙工作的原理和关键代码，通过实际案例分析，展示了如何在Android平台上开发一个具有文件传输功能的即时通讯应用程序。 Eclipse作为开发工具，被用来构建这个基于蓝牙的Android即时通讯实例...
Android平台下蓝牙即时通讯系统设计与实现
通过分析蓝牙的工作原理和实例，作者展示了在Android环境中如何建立一个蓝牙即时通讯应用，尤其是在文件传输方面的实现。 在设计部分，论文作者通过Eclipse这样的集成开发环境，实现了一个基于蓝牙的即时通讯应用...
用NFC连接蓝牙实现IM即时通讯
03-08
用NFC连接蓝牙，通过蓝牙实现即时通讯
Android平台的蓝牙即时通讯系统设计与实现
作者通过对一个蓝牙即时通讯实例的分析，展示了如何在Android平台上设计并实现一个能够进行文件发送的即时通讯软件。这个实例可能涉及蓝牙适配器的配置、数据包的封装和解封装、以及与蓝牙设备的交互等技术细节。...
BluetoothChatting:蓝牙即时通信，界面仿微信， 自动配对
05-02
BluetoothChatting 基于蓝牙即时通信，界面仿微信， 自动配对。 效果图！
基于蓝牙实现即时通讯demo
05-13
基于蓝牙实现即时通讯demo
简易的安卓蓝牙通信demo
11-23
简易的安卓蓝牙通信demo ，用android studio安装好app之后之后，选择设备进行配对，输入要发送的信息点击发送即可，代码比较简单适合初学者
android蓝牙连接通信的实现
02-26
通过蓝牙功能与设备进行连接以及获取设备传输过来的数据
Android实现的简单蓝牙程序示例
01-05
本文实例讲述了Android实现的简单蓝牙程序。分享给大家供大家参考，具体如下： 我将在这篇文章中介绍了的Android蓝牙程序。这个程序就是将实现把手机变做电脑PPT播放的遥控器：用音量加和音量减键来控制PPT页面的切换。 遥控器服务器端 首先，我们需要编写一个遥控器的服务器端（支持蓝牙的电脑）来接收手机端发出的信号。为了实现这个服务器端，我用到了一个叫做Bluecove（专门用来为蓝牙服务的！）的Java库。 以下是我的RemoteBluetoothServer类： public class RemoteBluetoothServer{ public static void main
蓝牙实时通信——蓝牙实时聊天demo
12-01 2532
这个程序中使用到了eventbus第三方组件，感兴趣的可以先去了解下，真的是越用越欲罢不能啊 首先先普及下知识： 什么是蓝牙 蓝牙是一种短距无线通信的技术规范。由于蓝牙具有工作在2.4GHz的ISM（industrial，scientific and medi-cal）频段；可以同时传输语音和数据；有很好的抗干扰能力和低功耗等特点。采用蓝牙技术构建由固定传感器节点组成的蓝牙传感器网络，是无线
安卓实现蓝牙聊天
qq_43385074的博客
06-02 275
安卓实现蓝牙聊天 码云地址 1.要在安卓使用蓝牙功能,首先需要在AndroidManifest.xml中申请权限 <uses-permission android:name="android.permission.BLUETOOTH"/> <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/> 2.关键代码块 2.1DeviceList: 这个主要是用来进行蓝牙的搜索功能 private f
Android蓝牙开发（三）之蓝牙通信
热门推荐
黄林晴
08-29 1万+
上篇文章：https://blog.csdn.net/huangliniqng/article/details/82187966 上篇文章我们讲解了，蓝牙配对和蓝牙连接相关知识，还没有了解的朋友可先移步上篇文章。 1.蓝牙通信简介 无论是做Java还是Android开发的朋友肯定都比较熟悉Socket的连接，在java中通信用的是Socket，同样的蓝牙之间通信（这里说的是经典蓝牙）方式...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值