《Android BLE 开发》--初学者

已于 2023-11-10 09:29:05 修改
阅读量2.6k 收藏 22
点赞数 3
分类专栏： 工具 文章标签： Android BLE 蓝牙
于 2018-08-25 16:17:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_29900103/article/details/82051601
版权

    本作者是一位安卓初学者，从事嵌入式开发岗位，由于工作需要开发一个BLE debug工具，所以开始了我的第一个安卓程序《BLE Tool》，因为作者学习安卓加开发只用了10天时间，目前只是把所有接口打通了而已，只提供如何怎么实现。开发之前，最好了解一下BLE的通信原理。最终实现的界面：

1.开启权限

在AndroidManifest.xml中添加一下代码：

    <uses-feature android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="andriod.permission.ACCESS_FINE_LOCATION"/>

2.初始化BLE

第一步：判断设备是否支持BLE功能

第二步：通过蓝牙管理器获取蓝牙适配器

第三步：判断设备是否打开蓝牙

在MainActivity.java中添加以下代码：

    public boolean initialize() {
        if(!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)){
            Log.e(TAG, "No support BLE.");
            finish();
        }

        if (mBluetoothManager == null) {
            mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
            if (mBluetoothManager == null) {
                Log.e(TAG, "Unable to initialize BluetoothManager.");
                return false;
            }
        }

        mBluetoothAdapter = mBluetoothManager.getAdapter();
        if (mBluetoothAdapter == null) {
            Log.e(TAG, "Unable to obtain a BluetoothAdapter.");
            return false;
        }

        if(!mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, 1);
        }
        return true;
    }

3.扫描设备实现

本作者时间扫描设备添加到Spanner控件中，在MainActivity.java中添加以下代码：

第一步：编写扫描函数

第二步：添加扫描回调函数

    private void scanLeDevice(final boolean enable) {
        if(enable) {
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    mScanning = false;
                    mBluetoothAdapter.stopLeScan(mLeScanCallback);
                }
            },SCAN_PERIOD);
            mScanning = true;
            mBluetoothAdapter.startLeScan(mLeScanCallback);
        }
    }
    private BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {
        @Override
        public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (device.getName() != null) {
                        if (!mSearchBluetoothList.contains(device)) {
                            mSearchBluetoothList.add(device);
                            mBLENameList.add(device.getName());
                        }
                    }
                }
            });
        }
    };

4.将扫描到的设备添加到Spanner控件中

在MainActivity.java中添加以下代码：

    private void setBLEName2Spanner(){
        BLE_List_Spinner.setOnItemSelectedListener(this);
        mBLENameList.add("<BLE List>");
        ListAdapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,mBLENameList);
        ListAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        BLE_List_Spinner.setAdapter(ListAdapter);
    }

5.连接设备

在Spanner控件中选择要连接的设备，Spanner的选择事件实现，在MainActivity.java中添加以下代码：

    @Override
    public void onItemSelected(AdapterView<?> parent,View view,int position,long id)
    {
        disconnect();
        close();
        String item = parent.getSelectedItem().toString();
        if(item != "<BLE List>") {
            for(BluetoothDevice device : mSearchBluetoothList) {
                if(device.getName().equals(item)) {
                    if(connect(device.getAddress()) == true) {
                        BLE_Connect_Button.setText("BLE DISCONNECT");
                    }
                }
            }
        }
    }
    public void onNothingSelected(AdapterView<?> arg0)
    {

    }

连接函数的实现，在MainActivity.java中添加以下代码：

    public boolean connect(final String address) {
        if (mBluetoothAdapter == null || address == null) {
            Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
            return false;
        }
        if (mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress)
                && mBluetoothGatt != null) {
            Log.d(TAG, "Trying to use an existing mBluetoothGatt for connection.");
            if (mBluetoothGatt.connect()) {
                mConnectionState = STATE_CONNECTING;
                return true;
            } else {
                return false;
            }
        }
        final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
        if (device == null) {
            Log.w(TAG, "Device not found.  Unable to connect.");
            return false;
        }
        mBluetoothGatt = device.connectGatt(this, false, mGattCallback);
        Log.d(TAG, "Trying to create a new connection.");
        mBluetoothDeviceAddress = address;
        mConnectionState = STATE_CONNECTING;
        System.out.println("device.getBondState==" + device.getBondState());
        return true;
    }

6.断开连接

断开连接函数的实现，在MainActivity.java中添加以下代码：

    public void disconnect() {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        mBluetoothGatt.disconnect();
    }

7.读特征实现

读特征函数的实现，在MainActivity.java中添加以下代码：

    public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        mBluetoothGatt.readCharacteristic(characteristic);
    }

8.写特征实现

写特征函数的实现，在MainActivity.java中添加以下代码：

    public boolean writeCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return false;
        }
        return mBluetoothGatt.writeCharacteristic(characteristic);
    }

9.设置特征的通知的实现

特征通知函数的实现，在MainActivity.java中添加以下代码：

    public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,
                                              boolean enabled) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        boolean isEnableNotification = mBluetoothGatt.setCharacteristicNotification(characteristic,enabled);
        if(isEnableNotification) {
            List<BluetoothGattDescriptor>descriptorList = characteristic.getDescriptors();
            if(descriptorList != null && descriptorList.size() >0) {
                for(BluetoothGattDescriptor descriptor : descriptorList) {
                    descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                    mBluetoothGatt.writeDescriptor(descriptor);
                }
            }
        }
    }

10.关闭BLE实现

关闭函数的实现，在MainActivity.java中添加以下代码：

    public void close() {
        if (mBluetoothGatt == null) {
            return;
        }
        mBluetoothGatt.close();
        mBluetoothGatt = null;
    }

11.功能的回调函数的实现

从第5点到第10的最终事项都需要调用回调函数，回调函数的实现，在MainActivity.java中添加以下代码：

    private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            String intentAction;

            if (newState == BluetoothProfile.STATE_CONNECTED) {
                intentAction = ACTION_GATT_CONNECTED;
                mConnectionState = STATE_CONNECTED;
                gatt.discoverServices();
                broadcastUpdate(intentAction);
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                intentAction = ACTION_GATT_DISCONNECTED;
                mConnectionState = STATE_DISCONNECTED;
                Log.i(TAG, "Disconnected from GATT server.");
                broadcastUpdate(intentAction);
            }
        }
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                supportedGattServices = gatt.getServices();
                for (BluetoothGattService gattService : supportedGattServices) {
                    if(gattService.getUuid().toString().equals("0000fe8f-0000-1000-8000-00805f9b34fb")) {
                        gattCharacteristics = gattService.getCharacteristics();
                        for(BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                            if(gattCharacteristic.getUuid().toString().equals("44fa50b2-d0a3-472e-a939-d80cf17638bb")) {
                                Log.e("BLE Tool", "Log Link Success");
                               //Log.e("BLE Tool", gattCharacteristic.getUuid().toString());
                            }
                        }
                    }
                }
                broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED);
            }
            else {
                Log.w(TAG, "onServicesDiscovered received: " + status);
            }
        }
        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
                Log.e("BLE Tool", "Characteristic Read");
            }
        }
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
            Log.e("BLE Tool", "Characteristic Notify");
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
            if (status == BluetoothGatt.GATT_SUCCESS) {
                broadcastUpdate(ACTION_GATT_WRITE);
                Log.e("BLE Tool", "Characteristic Write");
            }
        }

    };

    private void broadcastUpdate(final String action){
        final Intent intent = new Intent(action);
        sendBroadcast(intent);
    }

    private void broadcastUpdate(final String action, final BluetoothGattCharacteristic characteristic) {
        final Intent intent = new Intent(action);
        final byte[] data = characteristic.getValue();

        for(int i =0; i<data.length; i++) {
            System.out.println("data..."+data[i]);
        }
        sendBroadcast(intent);
    }

说道这里基本把所有要实现的功能函数都说完了。

具体实现代码：

AndroidManifest.xml的代码：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.harrychen.bletool" >

    <uses-feature android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="andriod.permission.ACCESS_FINE_LOCATION"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">

    <Spinner
        android:id="@+id/BLE_List_Spinner"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        />

    <Button
        android:id="@+id/BLE_Connect_Button"
        android:text="BLE CONNECT"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/BLE_List_Spinner"
        android:textColor="#0000EE"
        android:textSize="15dp"
        />

    <TextView
        android:id="@+id/BLE_Log_Text"
        android:text="BLE Log:"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/BLE_Connect_Button"
        />

    <EditText
        android:id="@+id/BLE_Log_Edit"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/BLE_Log_Text"
        android:hint="BLE Log Show"
        android:inputType="textMultiLine"
        android:gravity="left|top"
        android:maxLines="15"
        android:focusable="false"
        android:scrollbars="vertical"
        />

    <Button
        android:id="@+id/Log_Clear_Button"
        android:text="CLEAR LOG"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/BLE_Log_Edit"
        android:textColor="#0000EE"
        android:textSize="15dp"
        />

    <Button
        android:id="@+id/Read_Button"
        android:text="READ"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/Log_Clear_Button"
        android:layout_alignLeft="@+id/Log_Clear_Button"
        android:textColor="#0000EE"
        android:textSize="15dp"
        />

    <Button
        android:id="@+id/Write_Button"
        android:text="WRITE"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/Log_Clear_Button"
        android:layout_alignRight="@+id/Log_Clear_Button"
        android:textColor="#0000EE"
        android:textSize="15dp"
        />

    <Button
        android:id="@+id/Notify_Button"
        android:text="NOTIFY"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/Read_Button"
        android:textColor="#0000EE"
        android:textSize="15dp"
        />

</RelativeLayout>

MainActivity.java

package com.example.harrychen.bletool;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Spinner;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class MainActivity extends Activity implements AdapterView.OnItemSelectedListener{
    private final static String TAG = MainActivity.class.getSimpleName();

    private BluetoothManager mBluetoothManager;
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothGattCharacteristic mBluetoothtCharacteristic;
    private String mBluetoothDeviceAddress;
    private BluetoothGatt mBluetoothGatt;
    private int mConnectionState = STATE_DISCONNECTED;
    private Handler mHandler =new Handler();
    private boolean mScanning;
    private static final long SCAN_PERIOD = 5000;
    List<BluetoothGattService> supportedGattServices;
    List<BluetoothGattCharacteristic> gattCharacteristics;

    private List<String> mBLENameList = new ArrayList<String>();
    private ArrayAdapter<String> ListAdapter;
    private List<BluetoothDevice> mSearchBluetoothList = new ArrayList<>();

    private static final int STATE_DISCONNECTED = 0;
    private static final int STATE_CONNECTING = 1;
    private static final int STATE_CONNECTED = 2;

    public final static String ACTION_GATT_CONNECTED = "com.charon.www.NewBluetooth.ACTION_GATT_CONNECTED";
    public final static String ACTION_GATT_DISCONNECTED = "com.charon.www.NewBluetooth.ACTION_GATT_DISCONNECTED";
    public final static String ACTION_GATT_SERVICES_DISCOVERED = "com.charon.www.NewBluetooth.ACTION_GATT_SERVICES_DISCOVERED";
    public final static String ACTION_DATA_AVAILABLE = "com.charon.www.NewBluetooth.ACTION_DATA_AVAILABLE";
    public final static String EXTRA_DATA = "com.charon.www.NewBluetooth.EXTRA_DATA";
    public final static String DEVICE_TWO_ADDRESS = "com.example.bluetooth.le.DEVICE_TWO_ADDRESS";
    public final static String ACTION_GATT_WRITE= "com.example.bluetooth.le.ACTION_GATT_WRITE";

    public List<UUID> writeUuid = new ArrayList<>();
    public List<UUID> readUuid =new ArrayList<>();
    public List<UUID> notifyUuid =new ArrayList<>();

    private Spinner BLE_List_Spinner;
    private Button BLE_Connect_Button;
    private Button Log_Clear_Button;
    private Button Read_Button;
    private Button Write_Button;
    private Button Notify_Button;
    private EditText BLE_Log_Edit;

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

        BLE_List_Spinner = (Spinner)findViewById(R.id.BLE_List_Spinner);
        BLE_Connect_Button = (Button)findViewById(R.id.BLE_Connect_Button);
        Log_Clear_Button = (Button)findViewById(R.id.Log_Clear_Button);
        Read_Button = (Button)findViewById(R.id.Read_Button);
        Write_Button = (Button)findViewById(R.id.Write_Button);
        Notify_Button = (Button)findViewById(R.id.Notify_Button);
        BLE_Log_Edit = (EditText)findViewById(R.id.BLE_Log_Edit);

        initialize();
        scanLeDevice(true);
        setBLEName2Spanner();

        BLE_Connect_Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (BLE_Connect_Button.getText().equals("BLE DISCONNECT")) {
                    BLE_Connect_Button.setText("BLE CONNECT");
                    disconnect();
                    close();
                } else if (BLE_Connect_Button.getText().equals("BLE CONNECT")) {
                    BLE_Connect_Button.setText("BLE DISCONNECT");
                    connect(mBluetoothDeviceAddress);
                }
            }
        });

        Log_Clear_Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                BLE_Log_Edit.setText("");
            }
        });

        Read_Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for(BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                    if(gattCharacteristic.getUuid().toString().equals("00000000-0000-0061-6180-00030006ff08")) {
                        mBluetoothtCharacteristic = gattCharacteristic;
                    }
                }
                readCharacteristic(mBluetoothtCharacteristic);
            }
        });

        Write_Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                    if (gattCharacteristic.getUuid().toString().equals("00000000-0000-0061-6180-00030006ff08")) {
                        mBluetoothtCharacteristic = gattCharacteristic;
                    }
                }
                byte[] value = new byte[10];
                value[0] = 0x02;
                mBluetoothtCharacteristic.setValue(value);
                writeCharacteristic(mBluetoothtCharacteristic);
            }
        });

        Notify_Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for(BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                    if(gattCharacteristic.getUuid().toString().equals("44fa50b2-d0a3-472e-a939-d80cf17638bb")) {
                        mBluetoothtCharacteristic = gattCharacteristic;
                        Log.w("Notify",gattCharacteristic.getUuid().toString());
                    }
                }
                setCharacteristicNotification(mBluetoothtCharacteristic, true);
            }
        });

    }

    @Override
    protected void onResume(){
        super.onResume();
        registerReceiver(mGattUpdateReceiver,makeGattUpdateIntentFilter());
    }

    public boolean initialize() {
        if(!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)){
            Log.e(TAG, "No support BLE.");
            finish();
        }

        if (mBluetoothManager == null) {
            mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
            if (mBluetoothManager == null) {
                Log.e(TAG, "Unable to initialize BluetoothManager.");
                return false;
            }
        }

        mBluetoothAdapter = mBluetoothManager.getAdapter();
        if (mBluetoothAdapter == null) {
            Log.e(TAG, "Unable to obtain a BluetoothAdapter.");
            return false;
        }

        if(!mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, 1);
        }
        return true;
    }

    private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            String intentAction;

            if (newState == BluetoothProfile.STATE_CONNECTED) {
                intentAction = ACTION_GATT_CONNECTED;
                mConnectionState = STATE_CONNECTED;
                gatt.discoverServices();
                broadcastUpdate(intentAction);
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                intentAction = ACTION_GATT_DISCONNECTED;
                mConnectionState = STATE_DISCONNECTED;
                Log.i(TAG, "Disconnected from GATT server.");
                broadcastUpdate(intentAction);
            }
        }
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                supportedGattServices = gatt.getServices();
                for (BluetoothGattService gattService : supportedGattServices) {
                    if(gattService.getUuid().toString().equals("0000fe8f-0000-1000-8000-00805f9b34fb")) {
                        gattCharacteristics = gattService.getCharacteristics();
                        for(BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                            if(gattCharacteristic.getUuid().toString().equals("44fa50b2-d0a3-472e-a939-d80cf17638bb")) {
                                Log.e("BLE Tool", "Log Link Success");
                               //Log.e("BLE Tool", gattCharacteristic.getUuid().toString());
                            }
                        }
                    }
                }
                broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED);
            }
            else {
                Log.w(TAG, "onServicesDiscovered received: " + status);
            }
        }
        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
                Log.e("BLE Tool", "Characteristic Read");
            }
        }
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
            Log.e("BLE Tool", "Characteristic Notify");
        }

        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            super.onCharacteristicWrite(gatt, characteristic, status);
            if (status == BluetoothGatt.GATT_SUCCESS) {
                broadcastUpdate(ACTION_GATT_WRITE);
                Log.e("BLE Tool", "Characteristic Write");
            }
        }

    };

    private void broadcastUpdate(final String action){
        final Intent intent = new Intent(action);
        sendBroadcast(intent);
    }

    private void broadcastUpdate(final String action, final BluetoothGattCharacteristic characteristic) {
        final Intent intent = new Intent(action);
        final byte[] data = characteristic.getValue();

        for(int i =0; i<data.length; i++) {
            System.out.println("data..."+data[i]);
        }
        sendBroadcast(intent);
    }

    public class LocalBinder extends Binder {
        public MainActivity getService() {
            return MainActivity.this;
        }
    }
    public boolean onUnbind(Intent intent) {
        close();
        return onUnbind(intent);
    }
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    private final IBinder mBinder = new LocalBinder();

    public boolean connect(final String address) {
        if (mBluetoothAdapter == null || address == null) {
            Log.w(TAG, "BluetoothAdapter not initialized or unspecified address.");
            return false;
        }
        if (mBluetoothDeviceAddress != null && address.equals(mBluetoothDeviceAddress)
                && mBluetoothGatt != null) {
            Log.d(TAG, "Trying to use an existing mBluetoothGatt for connection.");
            if (mBluetoothGatt.connect()) {
                mConnectionState = STATE_CONNECTING;
                return true;
            } else {
                return false;
            }
        }
        final BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
        if (device == null) {
            Log.w(TAG, "Device not found.  Unable to connect.");
            return false;
        }
        mBluetoothGatt = device.connectGatt(this, false, mGattCallback);
        Log.d(TAG, "Trying to create a new connection.");
        mBluetoothDeviceAddress = address;
        mConnectionState = STATE_CONNECTING;
        System.out.println("device.getBondState==" + device.getBondState());
        return true;
    }

    public void disconnect() {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        mBluetoothGatt.disconnect();
    }

    public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        mBluetoothGatt.readCharacteristic(characteristic);
    }

    public boolean writeCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return false;
        }
        return mBluetoothGatt.writeCharacteristic(characteristic);
    }

    public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,
                                              boolean enabled) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        boolean isEnableNotification = mBluetoothGatt.setCharacteristicNotification(characteristic,enabled);
        if(isEnableNotification) {
            List<BluetoothGattDescriptor>descriptorList = characteristic.getDescriptors();
            if(descriptorList != null && descriptorList.size() >0) {
                for(BluetoothGattDescriptor descriptor : descriptorList) {
                    descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                    mBluetoothGatt.writeDescriptor(descriptor);
                }
            }
        }
    }

    public void close() {
        if (mBluetoothGatt == null) {
            return;
        }
        mBluetoothGatt.close();
        mBluetoothGatt = null;
    }

    public List<BluetoothGattService> getSupportedGattServices() {
        if (mBluetoothGatt == null) return null;
        return mBluetoothGatt.getServices();
    }
    public BluetoothGattService getSupportedGattServices(UUID uuid) {
        BluetoothGattService mBluetoothGattService;
        if (mBluetoothGatt == null) return null;
        mBluetoothGattService = mBluetoothGatt.getService(uuid);
        return mBluetoothGattService;
    }

    //--------------------------------------Scan BLE----------------------------------
    private void scanLeDevice(final boolean enable) {
        if(enable) {
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    mScanning = false;
                    mBluetoothAdapter.stopLeScan(mLeScanCallback);
                }
            },SCAN_PERIOD);
            mScanning = true;
            mBluetoothAdapter.startLeScan(mLeScanCallback);
        }
    }
    private BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {
        @Override
        public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (device.getName() != null) {
                        if (!mSearchBluetoothList.contains(device)) {
                            mSearchBluetoothList.add(device);
                            mBLENameList.add(device.getName());
                        }
                    }
                }
            });
        }
    };

    private final BroadcastReceiver mGattUpdateReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            if(ACTION_DATA_AVAILABLE.equals(action)) {
                String data = intent.getStringExtra(EXTRA_DATA);
                BLE_Log_Edit.setText("aaaa"+data);
                //System.out.println("Receiver..."+data);
            }
        }
    };

    private static IntentFilter makeGattUpdateIntentFilter() {
        final IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(ACTION_GATT_CONNECTED);
        intentFilter.addAction(ACTION_GATT_DISCONNECTED);
        intentFilter.addAction(ACTION_GATT_SERVICES_DISCOVERED);
        intentFilter.addAction(ACTION_DATA_AVAILABLE);
        return intentFilter;
    }

    private void setBLEName2Spanner(){
        BLE_List_Spinner.setOnItemSelectedListener(this);
        mBLENameList.add("<BLE List>");
        ListAdapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,mBLENameList);
        ListAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        BLE_List_Spinner.setAdapter(ListAdapter);
    }

    @Override
    public void onItemSelected(AdapterView<?> parent,View view,int position,long id)
    {
        disconnect();
        close();
        String item = parent.getSelectedItem().toString();
        if(item != "<BLE List>") {
            for(BluetoothDevice device : mSearchBluetoothList) {
                if(device.getName().equals(item)) {
                    if(connect(device.getAddress()) == true) {
                        BLE_Connect_Button.setText("BLE DISCONNECT");
                    }
                }
            }
        }
    }
    public void onNothingSelected(AdapterView<?> arg0)
    {

    }

}

Rice嵌入式开发
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
安卓基于BLE的蓝牙开发入门
fjnu_se的博客
06-08 938
BLE蓝牙开发简单入门BLE背景介绍引言BLE简介Gatt协议以及必备知识蓝牙开发涉及的API介绍BLE实战准备真机调试权限准备写两个简单的页面扫描设备主界面扫描设备信息界面实现扫描并返回检测到的设备连接设备的数据读写总结 BLE背景介绍 引言 如今,蓝牙的使用在生活中是越来越常见了,各色各样的运动手环、体脂称以及无线耳机都用到了蓝牙功能,如今火热的keep、小米运动等app也是通过简单的蓝牙连接与运动手环进行交互,因此通过本博客对安卓的蓝牙开发部分做一个简单的入门 BLE简介 蓝牙低能耗（Bluetoo
Android BLE开发入门教程
KevinSuper9的博客
11-12 664
关于BLE开发，网上相关的资料其实也不少，大多数资料介绍的还是很不错，不过我这边资料，主要侧重代码方便的介绍及使用。 1 我的这边是基于Android6.0以上版本开发的所以首先就得获取授权： //请求蓝牙权限 if (Build.VERSION.SDK_INT &gt;= Build.VERSION_CODES.M) { if (this.checkSelfPermission(M...
安卓BLE开发教程（一） BLE基础
SoldierJazz的专栏
12-20 4872
我试图以一种简单的方式去把重要的事情讲清楚。目的是希望BLE协议栈和基础概念简单化，让自己及类似的安卓开发者可以在较短的时间内把握住BLE的核心及使用方法。BLE本身很复杂，但对于安卓开发而言只要抓住一些核心点，便已足够。如果你想全面了解BLE协议栈，包括分层及每层功能，那么你从这里可能得不到答案。 1、BLE协议栈层次 然而，安卓BLE开发不用理解如此复杂的分层结构。因为我们不是在开发B...
Android BLE 开发官方示例
04-04
谷歌官方提供的Android平台上的关于低功耗蓝牙开发的示例代码，该示例包含了Android低功耗蓝牙开发的完整过程：（低功耗蓝牙可简称“BLE”） 1、声明蓝牙权限 2、设置BLE 3、扫描BLE 4、连接到GATT服务器（即低功耗蓝牙设备） 5、读写BLE属性（即收发数据） 6、接收GATT通知 7、关闭GATT客户端
Android 蓝牙BLE开发详解
weixin_34274029的博客
07-12 1105
1.介绍 蓝牙是一种短距离的无线通信技术，可以实现固定设备、移动设备之间的数据交换。一般将蓝牙分为两大类，蓝牙3.0规范之前的版本称为传统蓝牙，蓝牙4.0规范之后的版本称为低功耗蓝牙，也就是常说的BLE（Bluetooth Low Energy）。 本文主要讲解的是Android设备与BLE设备之间的通信，Android 从4.3版本（API Level 18）开始支持BLE通信。 2.开发流程 ...
安卓低功耗蓝牙（BLE）开发教程
anonymousCoder的博客
07-11 1035
翻译的官方文档，原文在这里：点击打开链接 ，本人对部分内容进行了微调，大意和原文一致。 蓝牙低功耗 Android 4.3（API级别18）为处于中心角色的低能耗蓝牙（BLE）引入了内置的平台支持，并为应用程序提供了可用于发现设备，查询服务和传输信息的API。 常见用例包括： 在附近设备之间传输少量数据。 与Google Beacons
ble-android-helper:辅助功能可将低功耗蓝牙（BLE）与Android集成
04-03
`ble-android-helper-master`目录下的代码示例可能展示了如何在实际应用中使用此库，这对于初学者尤其有用。 总之，`ble-android-helper`是Android开发者集成BLE功能的有力助手，它通过提供一套简洁、易用的API，...
Node.js-EasyBle主要用于简化安卓BLE操作流程降低BLE开发繁琐程度
08-12
对于初学者来说，可以通过阅读源代码和示例了解其工作原理，并根据自己的需求进行定制和扩展。在实际开发过程中，确保遵循Android BLE的最佳实践，如处理异步操作、正确释放资源和管理连接状态，以保证应用的稳定性...
android-sdk-sources-android-19.rar
04-17
《Android SDK 源码分析：深入理解 Android 19 版本》 在移动开发领域，Android SDK 是开发者不可或缺的工具集，它包含了...无论是初学者还是经验丰富的开发者，对Android SDK源码的探索都是一项值得投入的长期任务。
使用Blynk和Arduino的BLE机器人-项目开发
03-31
Blynk是一款强大的应用程序，允许用户通过手机或平板电脑界面与硬件设备进行交互，而Arduino则是一种流行的开源电子原型平台，非常适合初学者和专业开发者。 首先，我们来了解Blynk的基本概念。Blynk是一个基于iOS...
Android蓝牙开发系列文章-玩转BLE开发（一）
01-20
我们在《Android蓝牙开发系列文章-策划篇》中计划讲解一下蓝牙BLE，现在开始第一篇：Android蓝牙开发系列文章-玩转BLE开发（一）。计划要写的BLE文章至少分四篇，其他三篇分别讲解：BLE Server端编码（用手机模拟外围设备），BLE Beacon功能，BLE设备通信（利用自有协议实现Client和Server端通信，在Server端信息改变时，自动上报给Client）。 本文主要内容：编码实现BLE Client端，实现手机与蓝牙体重秤之间的通信 所用的设备：华为荣耀7手机，微信小程序，乐心体重秤 目录 1.基本概念 2.先来认识一下我们的设备 3、认识BLE Client编
《Android蓝牙BLE的详细讲解》 PDF
08-23
《Android蓝牙BLE的详细讲解》
Android频率计数器-项目开发
03-31
Arduino是一个开源电子平台，适合初学者和专业人士进行电子原型制作。在这个项目中，Arduino将接收来自信号源的输入，并通过内置的ADC（模拟数字转换器）将其转换为数字信号。然后，Arduino通过蓝牙模块将这些数据...
Android BLE 开发
xiaowang_lj的博客
02-25 2363
connect()和connectGatt() 都是连接BLE设备的方法，但二者用法不同。 connectGatt是BluetoothDevice类下的方法，功能是向BLE设备发起连接，然后得到一个BluetoothGatt类型的返回值，利用这个返回值可以进行下一步操作。 connect是BluetoothGatt类下的方法，功能是re-connect，重新连接。如果BLE设备和APP已经连接过，但是因为设备超出了蓝牙的连接范围而断掉，那么当设备重新回到连接范围内时，可以通过connect()重新连接.
【Android】BLE 蓝牙开发流程篇
Android技术之家
08-12 1540
携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第 4 天，点击查看活动详情前言本文旨在梳理BLE蓝牙开发的主要流程，其中涉及到其他的知识，将会单独成文梳理。如有任何疑问，可评论区留言讨论。功能Android 官方文档扫描其他蓝牙设备连接其他设备（通过服务发现连接到其他设备）与其他设备进行双向数据传输管理多个连接......(查询本地蓝牙适配器的配...
Android BLE开发详解
05-16 2117
1、开篇 本文将主要讲述Android应用开发中对BLE API的使用。Android 4.3（API 18）开始支持蓝牙4.0，但此时Android手机只能作为中心设备或者说主设备，不能作为从设备。Android 5.0（API 21）以后，Android开始支持从设备模式。Android 4.3和5.0以后的API会有一些差别，本文实例会使用5.0以后的API。本文会分别讲解主设备和从设备两种模式下的开发流程。 2、从设备模式 先从从设备模式开始，从设备的工作是发送广播，等待主设备发起连接，双方通过约定
（Android）低功耗蓝牙（BLE）开发一文全（详）解
最新发布
zl4302647的博客
08-25 9092
蓝牙ble android
Android BLE开发——Android手机与BLE终端通信初识
weixin_30708329的博客
07-22 95
蓝牙BLE官方Demo下载地址: http://download.csdn.net/detail/lqw770737185/8116019参考博客地址： http://www.eoeandroid.com/thread-563868-1-1.html?_dsign=843d16d6 设备：MX5手机一台，农药残留检测仪一台（BLE终端设备） 目的：...
低功耗蓝牙BLE - Android BLE 开发笔记
Hsy的博客
09-25 1294
目录 本文前序 Android API选择 Android BLE开发流程 获取权限 打开蓝牙 检查 Android设备 是否支持BLE 开启蓝牙 查找BLE设备 简单扫描 进阶 建立连接 connectGatt( ) BluetoothGattCallback( ) 获取服务和特征值 打开通知 通讯 读特征值Demo 写特征值Demo 关闭连接 Goo...
蓝牙4.0低功耗技术：BLE开发与实践指南
《BLE开发指南》是一本实用的教程，适合初学者了解和学习BLE技术，同时也为有经验的开发者提供了深入研究和实践BLE协议栈的路径。通过本书，读者不仅可以理解BLE技术的原理，还能具备实际开发BLE应用的能力。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rice嵌入式开发

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值