Android手机与BLE终端通信

最新推荐文章于 2024-09-12 17:23:17 发布
最新推荐文章于 2024-09-12 17:23:17 发布
阅读量702 收藏
点赞数
分类专栏： android 文章标签： android 手机 通信 BLE 低功耗蓝牙
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AuroraExecue/article/details/77140606
版权

      Android 开发BLE通信，代码只能接收数据，没有写发送数据部分，接收数据时间间隔可自己修改，是工程中的一部分，只涉及蓝牙部分。代码中的UUID部分需要按自己的设备修改。

    代码下载地址：http://download.csdn.net/download/auroraexecue/9931371


布局部分：

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.hp.blecaresystem.MainActivity">

    <TextView
        android:layout_centerInParent="true"
        android:id="@+id/stata_data_show"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="数据显示"
        android:textSize="20dp"/>

    <LinearLayout
        android:layout_centerHorizontal="true"
        android:layout_alignParentBottom="true"
        android:orientation="horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <Button
            android:id="@+id/start_button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="连接蓝牙"/>

        <TextView
            android:layout_width="40dp"
            android:layout_height="wrap_content" />

        <Button
            android:id="@+id/stop_button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="断开设备"/>
    </LinearLayout>
</RelativeLayout>

Activity部分：

public class MainActivity extends AppCompatActivity {
    private Button start_button;
    private TextView stata_data_show;
    private Button stop_button;
    public final static String ACTION_DEVICE_CONECT = "com.example.hp.blecaresystem.ACTION_DEVICE_CONECT";
    public final static String ACTION_DEVICE_DISCONECT = "com.example.hp.blecaresystem.ACTION_DEVICE_DISCONECT";
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothManager mBluetoothManager;
    private static final int ENABLE_BT_REQUEST_ID = 1;
    private final static int msg_deviceconnected = 1;
    private final static int msg_devicedisconnected = 2;
    private final static int msg_bluedatachaged = 3;
    private static short[] raw_data;

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

        serviceinit();
        viewInit();
        blueInit();
        regesterReciver();
    }

    private void viewInit(){
        stata_data_show = (TextView) findViewById(R.id.stata_data_show);
        start_button = (Button)findViewById(R.id.start_button);
        stop_button = (Button)findViewById(R.id.stop_button);
        start_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                Intent intent= new Intent(ACTION_DEVICE_CONECT);
                sendBroadcast(intent);

            }
        });
        stop_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent= new Intent(ACTION_DEVICE_DISCONECT);
                sendBroadcast(intent);
            }
        });
    }

    private void serviceinit(){
        Intent intent = new Intent(MainActivity.this,BLEService.class);
        startService(intent);
    }

    private void blueInit(){
        mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        mBluetoothAdapter = mBluetoothManager.getAdapter();
        if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, ENABLE_BT_REQUEST_ID);
        }
    }

    private void regesterReciver(){
        IntentFilter mfilter = new IntentFilter();
        mfilter.addAction(BLEService.ACTION_GATT_CONNECTED);
        mfilter.addAction(BLEService.ACTION_GATT_DISCONNECTED);
        mfilter.addAction(BLEService.ACTION_DATA_AVAILABLE);
        registerReceiver(mReciver,mfilter);
    }
    private void unregesterReciver(){
        unregisterReceiver(mReciver);
    }
    private BroadcastReceiver mReciver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(BLEService.ACTION_GATT_CONNECTED)){
                mHandler.sendEmptyMessage(msg_deviceconnected);
            }else if (action.equals(BLEService.ACTION_GATT_DISCONNECTED)){
                mHandler.sendEmptyMessage(msg_devicedisconnected);
            }else if (action.equals(BLEService.ACTION_DATA_AVAILABLE)){
                raw_data = intent.getShortArrayExtra("rawdata");
                mHandler.sendEmptyMessage(msg_bluedatachaged);
            }
        }
    };
    Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case msg_deviceconnected:
                    Toast.makeText(MainActivity.this,"蓝牙已连接！",Toast.LENGTH_SHORT).show();
                    break;
                case msg_devicedisconnected:
                    Toast.makeText(MainActivity.this,"蓝牙已断开！",Toast.LENGTH_SHORT).show();
                    break;
                case msg_bluedatachaged:
                    if (raw_data!=null && raw_data.length>0)
                        stata_data_show.setText("" + raw_data[0] + " " + raw_data[1] + " " + raw_data[2]);
                    break;
                default:
                    break;
            }
        }
    };
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregesterReciver();
    }
}

UUID 类部分：

public class BleDefinedUUIDS {
      final static public UUID CHARACTER_UUID = UUID.fromString("00001527-1212-efde-1523-785feabcd123");
      final static public UUID SERVICE_UUID = UUID.fromString("00001526-1212-efde-1523-785feabcd123");
}

Service部分：

public class BLEService extends Service {
    private final static String TAG = BLEService.class.getCanonicalName();
    public final static String ACTION_GATT_CONNECTED = "com.example.bluetooth.le.ACTION_GATT_CONNECTED";
    public final static String ACTION_GATT_DISCONNECTED = "com.example.bluetooth.le.ACTION_GATT_DISCONNECTED";
    public final static String ACTION_DATA_AVAILABLE = "com.example.bluetooth.le.ACTION_DATA_AVAILABLE";
    public final static String ACTION_EXTRA_DATA = "com.example.bluetooth.le.ACTION_EXTRA_DATA";
    private final static int msg_startconnect = 1;
    private final static int msg_connectdevice = 2;
    private final static int msg_disconnecte = 3;
    private final static int msg_getbluedata = 4;
    private final static int msg_datagetted = 5;
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothManager mBluetoothManager;
    private BluetoothGattCharacteristic mCharacteristic;
    private static short[] GESONSOR_DATA;
    private BluetoothGatt mBluetoothGatt = null;
    private final static String BLUE_ADRESS = "F7:96:42:E4:8C:57";
    private BluetoothDevice DEVICE = null;
    private static boolean bluedatastate = false;
    private final static int GET_DATA_TIME = 100; //间隔100毫秒获得一次数据

    public BLEService() {
    }

    @Override
    public void onCreate() {
        super.onCreate();
        regesterReciver();

        mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        mBluetoothAdapter = mBluetoothManager.getAdapter();
    }
    public void startScanning() {
        final UUID[] uuids = new UUID[] { BleDefinedUUIDS.SERVICE_UUID };
        mBluetoothAdapter.startLeScan(uuids,mDeviceFoundCallback);
    }

    /* stops current scanning */
    public void stopScanning() {
        mBluetoothAdapter.stopLeScan(mDeviceFoundCallback);
    }

    private BluetoothAdapter.LeScanCallback mDeviceFoundCallback = new BluetoothAdapter.LeScanCallback() {
        @Override
        public void onLeScan(BluetoothDevice device, int i, byte[] bytes) {
            if (IsTargetBlueDecive(device)){
                stopScanning();
            }
        }
    };

    private boolean IsTargetBlueDecive(BluetoothDevice device){
        if (device == null)
            return false;
        if (device.getAddress().equals(BLUE_ADRESS)){
            this.DEVICE = device;
            mHandler.sendEmptyMessage(msg_connectdevice);
            return true;
        }
        return false;
    }

    private boolean connectDevice(String address){
        if (mBluetoothAdapter==null || address==null)
            return false;
        //如果之前有连接过就直接连接，重新连接
        if (mBluetoothGatt != null)
            return mBluetoothGatt.connect();
        mBluetoothGatt = DEVICE.connectGatt(this,false,mGattCallback);
        return true;
    }

    public void disconnectDevice()
    {
        if (mBluetoothGatt != null)
        {
            mBluetoothGatt.disconnect();
        }
    }

    public void closeDevice()
    {
        if (mBluetoothGatt != null)
        {
            mBluetoothGatt.close();
        }
    }
    public void requestCharacteristicValue(BluetoothGattCharacteristic ch) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null)
            return;
        mBluetoothGatt.readCharacteristic(ch);
    }

    private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
        /**
         * 连接状态改变回调
         * @param gatt
         * @param status
         * @param newState
         */
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            super.onConnectionStateChange(gatt, status, newState);
            if (newState == BluetoothProfile.STATE_CONNECTED){
                mBluetoothGatt.discoverServices();
                Log.w(TAG, "onConnectionStateChange" + " = " + mBluetoothGatt);
                Intent intent = new Intent(ACTION_GATT_CONNECTED);
                sendBroadcast(intent);
                Log.w(TAG, "handleMessage" + " = 连接成功！");
            }else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                Intent intent = new Intent(ACTION_GATT_DISCONNECTED);
                sendBroadcast(intent);
                bluedatastate = false;
                Log.w(TAG, "handleMessage" + " = 连接断开！");
            }
        }
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            super.onServicesDiscovered(gatt, status);
            if (status == BluetoothGatt.GATT_SUCCESS) {
                // now, when services discovery is finished, we can call getServices() for Gatt
                mCharacteristic = mBluetoothGatt.getService(BleDefinedUUIDS.SERVICE_UUID)
                        .getCharacteristic(BleDefinedUUIDS.CHARACTER_UUID);
                mHandler.sendEmptyMessage(msg_getbluedata);
                Log.w(TAG, "onServicesDiscovered" + " = " + mCharacteristic);
            }else {

                Log.w(TAG, "onServicesDiscovered" + "获取失败");
            }
        }

        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            super.onCharacteristicChanged(gatt, characteristic);
            Log.w(TAG, "onCharacteristicRead" + " = 获得数据一次！");
            getCharacteristicValue(characteristic);
        }

        @Override
        public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
            super.onReadRemoteRssi(gatt, rssi, status);
        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicRead(gatt, characteristic, status);
            if (status == BluetoothGatt.GATT_SUCCESS){
                Log.w(TAG, "onCharacteristicRead" + " = 获得数据一次！");
                getCharacteristicValue(characteristic);
            }
        }
    };

    public void getCharacteristicValue(BluetoothGattCharacteristic ch) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null || ch == null)
            return;
        byte[] rawValue = ch.getValue();
        UUID uuid = ch.getUuid();
        if (uuid.equals(BleDefinedUUIDS.CHARACTER_UUID)){
            GESONSOR_DATA = toShortArray(rawValue);
            mHandler.sendEmptyMessage(msg_datagetted);
            Log.w(TAG, "getCharacteristicValue=" + GESONSOR_DATA[0] + " " + GESONSOR_DATA[1] + " " + GESONSOR_DATA[2]
                    + " " + GESONSOR_DATA[3] + " " + GESONSOR_DATA[4] + " " + GESONSOR_DATA[5]);
        }
    }

    public static short[] toShortArray(byte[] src) {
        int count = src.length >> 1;
        short[] dest = new short[count];
        for (int i = 0; i < count; i++) {
            dest[i] = (short) (src[i * 2] << 8 | src[2 * i + 1] & 0xff);
        }
        return dest;
    }

    Handler mHandler = new Handler(){
        @Override
        public void handleMessage(final Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case msg_startconnect:
                    Log.w(TAG, "handleMessage" + " = get commond!");
                    startScanning();
                    break;
                case msg_connectdevice:
                    connectDevice(DEVICE.getAddress());
                    Log.w(TAG, "handleMessage" + " = " + DEVICE.getName());
                    break;
                case msg_disconnecte:
                    bluedatastate = false;
                    disconnectDevice();
                    break;
                case msg_getbluedata:
                    bluedatastate = true;
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            while (bluedatastate){
                                if (mCharacteristic == null){
                                    Log.w(TAG, "run" + " = 启动异常！");
                                }else {
                                    requestCharacteristicValue(mCharacteristic);
                                    Log.w(TAG, "run" + " = 正常启动！");
                                }
                                try {
                                    Thread.sleep(GET_DATA_TIME);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }).start();
                    break;
                case msg_datagetted:
                    Intent intent = new Intent(ACTION_DATA_AVAILABLE);
                    intent.putExtra("rawdata",GESONSOR_DATA);
                    sendBroadcast(intent);
                    break;
                default:
                    break;
            }
        }
    };

    private void regesterReciver(){
        IntentFilter mfilter = new IntentFilter();
        mfilter.addAction(MainActivity.ACTION_DEVICE_CONECT);
        mfilter.addAction(MainActivity.ACTION_DEVICE_DISCONECT);
        registerReceiver(mReciver,mfilter);
    }
    private void unregesterReciver(){
        unregisterReceiver(mReciver);
    }
    private BroadcastReceiver mReciver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(MainActivity.ACTION_DEVICE_CONECT)){
                mHandler.sendEmptyMessage(msg_startconnect);
            }else if (action.equals(MainActivity.ACTION_DEVICE_DISCONECT)){
                mHandler.sendEmptyMessage(msg_disconnecte);
            }
        }
    };


    @Override
    public void onDestroy() {
        super.onDestroy();
        unregesterReciver();
        closeDevice();
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
}




AuroraExecue
关注
专栏目录
Android BLE开发之Android手机与BLE终端通信 程序文件
04-21
最近穿戴设备发展得很火，把相关技术也带旺了，其中一项是BLE（Bluetooth Low Energy）。BLE是蓝牙4.0的核心Profile，主打功能是快速搜索，快速连接，超低功耗保持连接和传输数据，弱点是数据传输速率低，由于BLE的低功耗特点，因此普遍用于穿戴设备。Android 4.3才开始支持BLE API，所以请各位客官把本文代码运行在蓝牙4.0和Android 4.3及其以上的系统，另外本文所用的BLE终端是一个蓝牙4.0的串口蓝牙模块。 PS：我的i9100刷了4.4系统后，竟然也能跟BLE蓝牙模块通信。
Android BLE开发之Android手机与BLE终端通信
热门推荐
hellogv的专栏
04-21 15万+
最近穿戴设备发展得很火，把相关技术也带旺了，其中一项是BLE（Bluetooth Low Energy）。BLE是蓝牙4.0的核心Profile，主打功能是快速搜索，快速连接，超低功耗保持连接和传输数据，弱点是数据传输速率低，由于BLE的低功耗特点，因此普遍用于穿戴设备。Android 4.3才开始支持BLE API，所以请各位客官把本文代码运行在蓝牙4.0和Android 4.3及其以上的系统，另外本文所用的BLE终端是一个蓝牙4.0的串口蓝牙模块。
安卓BLE蓝牙通讯
最新发布
weixin_41119184的博客
09-12 1076
正常情况下，当触发触发onConnectSuccess回调时，设备已经连上的蓝牙的GATT，此时可认为蓝牙已连接，此时中心设备是无法和外围设备通讯的，还需根据蓝牙协议绑定指定的特征UUID，一般中心设备接收数据的为NOTIFY_CHARACTERISTIC_UUID，向外围设备发送消息的为WRITE_CHARACTERISTIC_UUID，大部分外设备还有描述符，例如接收数据需要的描述符NOTIFY_DESCRIPTOR_UUID等。断开设备后，进行重新扫描，再次连接时，可接收到Notify的消息。
Android与蓝牙Ble之间的通信
weixin_30810583的博客
04-12 175
首先，先简单介绍一下ble的特征（注意：蓝牙4.0只有android4.3或4.3以上才支持） 1.BLE(Bluetooth Low Energy)，蓝牙4.0核心profile，主要特点是快速搜索，快速连接，超低功耗保持连接和数据传输，缺点：数据传输速率低，由于其具有低功耗特点，所以经常用在可穿戴设备之中。 2.关于BLE数据传输： a.profile可以理解为一种规范，一个标...
Android提高之Android手机与BLE终端通信
09-04
主要介绍了Android手机与BLE终端通信的方法,有很大的实用价值,需要的朋友可以参考下
android Ble通信
小男孩
12-18 679
你好
Android手机与BLE终端通信Demo
08-13
【Android手机与BLE终端通信Demo】是一个示例项目，展示了如何使用Android设备通过蓝牙低功耗（Bluetooth Low Energy，简称BLE）技术与外部BLE设备进行通信。在这个项目中，重点在于接收来自BLE设备的数据，同时提供...
Android手机与BLE终端通信详解：实用指南与代码优化
通过阅读和理解这部分内容，开发者可以学习到如何在Android设备上开发与BLE终端的高效通信应用，从而提升产品的实用性和用户体验。 总结来说，本文是Android开发者学习和实践BLE技术的一个实用指南，对于希望利用...
android蓝牙4.0通信源码,蓝牙4.0的手机与BLE终端通信
weixin_31481495的博客
05-29 238
package com.example.bluetooth.le;import java.util.ArrayList;import android.app.Activity;import android.bluetooth.BluetoothAdapter;import android.bluetooth.BluetoothDevice;import android.content.Contex...
Android手机通过蓝牙(BLE)与硬件进行通信(Android源码)
08-30
源码包含内容介绍: 1.Android手机通过蓝牙(BLE)与硬件进行通信(包括扫描,连接,发送,接收,注册服务等等) 2.控制手机音量 3. 实现控制第三方音乐播放器暂停、播放 4.使用AudioRecord和AudioTrack边录边播 详情请查看:https://blog.csdn.net/dengshunhao/article/details/82222296
android使用BLE通讯的demo
05-26
一个android使用BLE通讯的小demo，帮助那些新手快速入门，已经进行过简单的封装，方便使用。
android最完整的智能家居穿戴BLE通信框架
07-18
该框架是安卓BLE通信框架最完善的，一年前自己踩过坑。今天又有小伙伴咨询，分享一下。感谢作者！
Android 低功耗蓝牙BLE连接通信
hwx865的专栏
03-29 2620
简介 蓝牙（Bluetooth®）：是一种无线技术标准，可实现固定设备、移动设备和楼宇个人域网之间的短距离数据交换（使用2.4—2.485GHz的ISM波段的UHF无线电波）。蓝牙技术最初由电信巨头爱立信公司于1994年创制，当时是作为RS232数据线的替代方案。蓝牙可连接多个设备，克服了数据同步的难题。 蓝牙 4.0 蓝牙技术联盟于2010年6月30日正式推出蓝牙核心规格4.0 。它包...
Android-Ble蓝牙通讯开发–扫描,连接,发送和接收数据,分包解包(附源码)
Crazy程序猿
05-19 2万+
万物互联的物联网时代的已经来临，ble蓝牙开发在其中扮演着举重若轻的角色。最近刚好闲一点，抽时间梳理下这块的知识点。 涉及ble蓝牙通讯的客户端(开启、扫描、连接、发送和接收数据、分包解包)和服务端(初始化广播数据、开始广播、配置Services、Server回调操作)整个环节以及一些常见的问题即踩过的一些坑。
手把手教你Android手机与BLE终端通信--连接，发送和接收数据
丹丹的博客
06-27 2万+
如果你还没有看上一篇 手把手教你Android手机与BLE终端通信--搜索，你就先看看吧，因为这一篇要接着讲搜索到蓝牙后的连接，和连接后的发送和接收数据。     我的基本思想就是所有蓝牙操作都写在BluetoothController中，他有消息要发送时发送到BLEService中，service再发广播提示MainActivity更新页面。好了，切入正题。。     1，连接     首
android ble通信流程,Android BLE的一些基础知识及相关操作流程
weixin_36385240的博客
05-28 885
前言：本文主要描述Android BLE的一些基础知识及相关操作流程，不牵扯具体的业务实现，其中提供了针对广播包及响应包的解析思路，希望对正在或即将面临Android BLE开发的伙伴们有所引导。注：其中的单模、双模、BR、BT、BLE、蓝牙3.0、蓝牙4.0等概念混在一起可能比较难理解，不知下文描述是否清晰，如果有不理解的地方，欢迎留言交流！一、相关介绍 1、概述蓝牙无线技术是一种全球通用的短距...
Android 蓝牙BLE连接、广播、数据传输流程分析
手机-手表蓝牙开发工程师的博客
04-21 9289
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙低功耗ble 广播、扫描、连接、数据读写源码流程分析大全 - 点击下载 如今的社会已经从IT时代过渡到了DT时代，数据的重要性不言而喻。将数据安全快速的传输给对方是一件非常重要的事情，如今诞生了很多不同的传输技术，每一种传输技术都是为了和对方进行数据交互。BLE技术也是这样，它的最终目的就是为了在两个设备间进行数据交互。我们从BLE的本质出发，搞清楚它是如何实现数据交互的，也就真...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值