浅谈BLE

最新推荐文章于 2024-01-20 22:30:00 发布
最新推荐文章于 2024-01-20 22:30:00 发布
阅读量2.5k 收藏 3
点赞数
分类专栏： Android_ble 文章标签： android BLE 
    最近刚开始接触Android，Android编程对于一个学过C++的人来说，入门挺容易的；但想要做一名合格的Android开发工程师还有很长的路要走。当然这里仅限于我C++也不是学的很好，也只能说是个入门级别，大牛除外，大牛级别的人学什么编程语言都很快。

    说说BLE的特性吧。蓝牙4.0最重要的特性是省电，极低的运行和待机功耗可以使一粒纽扣电池连续工作数年之久。可以用于计步器、心律监视器、智能仪表、传感器物联网等众多领域。BLE通信由三部分Service、Characteristic、Descriptor构成，这三部分都由UUID作为唯一标示符。一个蓝牙4.0的终端可以包含多个Service，一个Service可以包含多个Characteristic，一个Characteristic包含一个Value和多个Descriptor，一个Descriptor包含一个Value。接下来说说gatt回调函数9个要实现的方法。
    private BluetoothGattCallback GattCallback = new BluetoothGattCallback() {
    // 这里有9个要实现的方法，看情况要实现那些，用到那些就实现那些
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState){};
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status){};
};

BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
BluetoothGatt gatt = device.connectGatt(this, false, mGattCallback);


:notification对应onCharacteristicChanged；
 
gatt.setCharacteristicNotification(characteristic, true);
:readCharacteristic对应onCharacteristicRead；
 
gatt.readCharacteristic(characteristic);
: writeCharacteristic对应onCharacteristicWrite；
 
gatt.wirteCharacteristic(mCurrentcharacteristic);
:连接蓝牙或者断开蓝牙 对应 onConnectionStateChange；
 
:readDescriptor对应onDescriptorRead；
 
:writeDescriptor对应onDescriptorWrite；
 
gatt.writeDescriptor(descriptor);
:readRemoteRssi对应onReadRemoteRssi；
 
gatt.readRemoteRssi()
:executeReliableWrite对应onReliableWriteCompleted；
:discoverServices对应onServicesDiscovered。


代码实现：
    实现步骤：1、开启蓝牙
              2、扫描蓝牙
              3、与外设建立gatt连接
              4、枚举服务以及对应的UUID号
              5、断开连接
    具体代码：
        MainActivity.java
package com.example.ble;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.Toast;

/**
 * @date 2015-07-31
 * @describe 
 * @author lai
 *
 */
@SuppressLint("NewApi")
public class MainActivity extends Activity {
private static Context mContext;// 上下文
private static final String TAG = MainActivity.class.getSimpleName();// 标志

private SharedPreferences sp = null;

private BluetoothAdapter mBluetoothAdapter = null;// 本地蓝牙设备

private Handler mHandler = null;// 用于postDelay
private boolean mScanning = false;// 循环标志位
private static final long SCAN_PERIOD = 10000;// 扫描10s
private static final int REQUEST_ENABLE_BT = 1;// 请求码

private ListView mListView = null;
private TestAdapter mAdapter = null;

@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
if (!checkBluetooth()) {
finish();
}
init();
		
}

@Override
protected void onResume() {
// TODO Auto-generated method stub
super.onResume();
System.out.println("2");
// 为了确保设备上蓝牙能使用, 如果当前蓝牙设备没启用,弹出对话框向用户要求授予权限来启用
		if (!mBluetoothAdapter.isEnabled()) {
			if (!mBluetoothAdapter.isEnabled()) {
				Intent enableBtIntent = new Intent(
						BluetoothAdapter.ACTION_REQUEST_ENABLE);
				startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
			}
		}
		mAdapter = new TestAdapter(mContext);
		mListView.setAdapter(mAdapter);
		if (mBluetoothAdapter.isEnabled()) {
			scanLeDevice(true);

		}
	}

	@Override
	protected void onPause() {

		super.onPause();
		scanLeDevice(false);
		mAdapter.clear();
		System.out.println("4");
	}

	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
		super.onDestroy();
		suiside();
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		// TODO Auto-generated method stub
		if (requestCode == REQUEST_ENABLE_BT
				&& resultCode == Activity.RESULT_CANCELED) {
			finish();
			return;
		}
		super.onActivityResult(requestCode, resultCode, data);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.main, menu);
		if (!mScanning) {
			menu.findItem(R.id.menu_stop).setVisible(false);
			menu.findItem(R.id.menu_scan).setVisible(true);
			menu.findItem(R.id.menu_refresh).setActionView(null);
		} else {
			menu.findItem(R.id.menu_stop).setVisible(true);
			menu.findItem(R.id.menu_scan).setVisible(false);
			menu.findItem(R.id.menu_refresh)
					.setActionView(R.layout.menurefresh);
		}
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		switch (item.getItemId()) {
		case R.id.menu_scan:
			mAdapter.clear();
			scanLeDevice(true);

			break;
		case R.id.menu_stop:
			scanLeDevice(false);
			break;
		}
		return true;
	}

	/**
	 * 判断是否支持蓝牙和BLE
	 * 
	 * @return
	 */
	private boolean checkBluetooth() {
		// 判断是否支持BLE
		if (!getPackageManager().hasSystemFeature(
				PackageManager.FEATURE_BLUETOOTH_LE)) {
			toast("ble not supported");
			return false;
		}

		// 初始化BluetoothAdapter
		final BluetoothManager bluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
		mBluetoothAdapter = bluetoothManager.getAdapter();

		// 检查设备上是否支持蓝牙不支 持就退出程序
		if (mBluetoothAdapter == null) {
			toast("bluetooth not supported");
			return false;
		}

		return true;
	}

	/**
	 * 初始化数据
	 */
	private void init() {
		mContext = this;
		mHandler = new Handler();
		sp = getSharedPreferences(Constant.SP_NAME, Context.MODE_PRIVATE);
		mListView = (ListView) findViewById(R.id.list_view);
		mListView.setOnItemClickListener(mItemClickListener);
		System.out.println("1");
	}

	/**
	 * 列表单击事件
	 */
	private OnItemClickListener mItemClickListener = new OnItemClickListener() {

		@Override
		public void onItemClick(AdapterView<?> arg0, View arg1, int position,
				long arg3) {
			// TODO Auto-generated method stub
			/**
			 * 跳转到BLEService 传递一个参数 一个地址 并把名字和地址保存起来
			 */
			System.out.println("3");
			BluetoothDevice mDevice = mAdapter.getDevice(position);
			toast(mDevice.getAddress());
			saveDeviceAddress(mDevice.getAddress());
			startTheService();

		}
	};

	/**
	 * 启动BLE通信服务
	 */
	private void startTheService() {
		Intent service = new Intent();
		service.setClass(mContext, BLEService.class);
		startService(service);
	}

	/**
	 * 把地址保存起来 以便服务可以使用
	 * 
	 * @param address
	 */
	private void saveDeviceAddress(String address) {
		Editor editor = sp.edit();
		editor.putString(Constant.KEY_DEVICE_ADDRESS, address);
		editor.commit();
	}

	/**
	 * 吐丝
	 * 
	 * @param text
	 */
	private void toast(String text) {
		Toast.makeText(mContext, text, Toast.LENGTH_SHORT).show();
	}

	/**
	 * 扫描BLE设备
	 * 
	 * @param enable
	 */
	private void scanLeDevice(final boolean enable) {
		if (enable) {
			mHandler.postDelayed(new Runnable() {
				@Override
				public void run() {
					mScanning = false;
					mBluetoothAdapter.stopLeScan(mLeScanCallback);
					invalidateOptionsMenu();
				}
			}, SCAN_PERIOD);

			mScanning = true;
			mBluetoothAdapter.startLeScan(mLeScanCallback);
		} else {
			mScanning = false;
			mBluetoothAdapter.stopLeScan(mLeScanCallback);
		}
		invalidateOptionsMenu();
	}

	/**
	 * BLE扫描回调函数，设备保存在remoteDevice里面
	 */
	private BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {

		@Override
		public void onLeScan(final BluetoothDevice device, int rssi,
				byte[] scanRecord) {
			// TODO Auto-generated method stub
			runOnUiThread(new Runnable() {
				@Override
				public void run() {
					mAdapter.addDevice(device);
					mAdapter.notifyDataSetChanged();
				}
			});
		}
	};

	/**
	 * 自杀
	 */
	private void suiside() {
		scanLeDevice(false);
		sp = null;
	}
}

  
TestAdapter.java


package com.example.ble;
import java.util.ArrayList;


import android.bluetooth.BluetoothDevice;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;


public class TestAdapter extends BaseAdapter {
	private ArrayList<BluetoothDevice> mLeDevices;
	private LayoutInflater mInflater;
	
	public TestAdapter(Context context) {
		mLeDevices = new ArrayList<BluetoothDevice>();
		mInflater = LayoutInflater.from(context);
	}


	@Override
	public int getCount() {
		// TODO Auto-generated method stub
		return mLeDevices.size();
	}


	@Override
	public Object getItem(int arg0) {
		// TODO Auto-generated method stub
		if (mLeDevices.size() <= arg0) {
			return null;}
		return mLeDevices.get(arg0);
	}


	@Override
	public long getItemId(int arg0) {
		// TODO Auto-generated method stub
		return arg0;
	}


	@Override
	public View getView(int position, View view, ViewGroup arg2) {
		// TODO Auto-generated method stub
		ViewHolder viewHolder;
		if (null == view) {
			viewHolder = new ViewHolder();


			view = mInflater.inflate(R.layout.item_ble, null);
			viewHolder.deviceName = (TextView) view
					.findViewById(R.id.device_name);


			view.setTag(viewHolder);
		} else {
			viewHolder = (ViewHolder) view.getTag();
		}


		BluetoothDevice device = mLeDevices.get(position);


		final String deviceName = device.getName();
		if (deviceName != null && deviceName.length() > 0)
			viewHolder.deviceName.setText(deviceName);
		else
			viewHolder.deviceName.setText("unknown name");


		return view;
	}


	private class ViewHolder {
		public TextView deviceName;


	}
	
	/**
	 * 设置数据源
	 * 
	 * @param mDevices
	 */
	public void setData(ArrayList<BluetoothDevice> mDevices) {
		this.mLeDevices = mDevices;


	}


	/**
	 * 添加设备
	 * 
	 * @param mDevice
	 */
	public void addDevice(BluetoothDevice mDevice) {


		if (!mLeDevices.contains(mDevice)) {
			mLeDevices.add(mDevice);
		}
	}


	/**
	 * 得到设备
	 * 
	 * @param position
	 * @return
	 */
	public BluetoothDevice getDevice(int position) {


		if (mLeDevices.size() <= position) {
			return null;
		}
		return mLeDevices.get(position);
	}


	/**
	 * 清空设备
	 */
	public void clear() {


		mLeDevices.clear();
	}
}



BLEService.java


package com.example.ble;
import java.util.List;
import android.annotation.SuppressLint;
import android.app.Service;
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.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.IBinder;
import android.util.Log;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;


public class BLEService extends Service {

private static byte[] testData = { 1, 2, 3 };
private static Context mContext;// 上下文
private static final String TAG = BLEService.class.getSimpleName();// TAG
private BluetoothManager mBluetoothManager = null;// 蓝牙管理器
private BluetoothAdapter mBluetoothAdapter = null;// 本地设备
private String mBluetoothDeviceAddress = null;// 远程设备地址
private BluetoothGatt mBluetoothGatt = null;// GATT通信
private BluetoothGattCharacteristic mCharacteristic = null;// 可读写可通知的
private SharedPreferences sp = null;
private static final boolean AUTO_CONNECT = true;// 是否自动连接
private static final boolean NOTIFICATION_ENABLED = true;
private int mConnectionState = STATE_DISCONNECTED;// 连接状态
private static final int STATE_DISCONNECTED = 0;// 断开连接
private static final int STATE_CONNECTING = 1;// 连接中
private static final int STATE_CONNECTED = 2;// 已连接
@Override
public IBinder onBind(Intent arg0) {
	// TODO Auto-generated method stub
return null;
}

@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
init();
}


@Override
public void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy();
suiside();
}


	@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
// 如果地址不为空就尝试连接 如果为空就跳到BLEActivity让用户去选择BLE设备
if (mBluetoothDeviceAddress != null) {
       if (connect(mBluetoothDeviceAddress)) {
System.out.println("mBluetoothDeviceAddress");			
	} else {
		}
} else {
Intent bleIntent = new Intent();
bleIntent.setClass(mContext, MainActivity.class);
bleIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(bleIntent);
	}
// return super.onStartCommand(intent, flags, startId);
return Service.START_STICKY;
}


	/**
	 * 各种初始化信息
	 */
private void init() {
mContext = this;
if (!initBluetooth()) {
	stopSelf();
	}
sp = getSharedPreferences(Constant.SP_NAME, Context.MODE_PRIVATE);
mBluetoothDeviceAddress = sp.getString(Constant.KEY_DEVICE_ADDRESS,null);
	}
	
private void toast(String text) {
Toast.makeText(mContext, text, Toast.LENGTH_SHORT).show();
}
	/**
	 * 初始化BluetoothManager和BluetoothAdapter
	 * 
	 * @return
	 */
private boolean initBluetooth() {
if (mBluetoothManager == null) {
mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
if (mBluetoothManager == null) {
	return false;
	}
}
mBluetoothAdapter = mBluetoothManager.getAdapter();
if (mBluetoothAdapter == null) {
	return false;
	}
return true;
}


	/**
	 * 自殺
	 */
private void suiside() {
disconnect();
close();
try {
	if (mBluetoothAdapter != null) {
	mBluetoothAdapter.disable();
	mBluetoothAdapter = null;
	mBluetoothManager = null;
	sp = null;
}
		} catch (Exception e) {
			toast("关闭蓝牙失败，请手动关闭");
		}
	}


	/**
	 * 关闭通信
	 */
private void close() {
if (mBluetoothGatt == null) {
	return;
	}
mBluetoothGatt.close();
mBluetoothGatt = null;
	}


	/**
	 * 建立通信連接
	 * 
	 * @param address
	 * @return
	 */
private boolean connect(final String address) {
if (mBluetoothAdapter == null || address == null) {
	return false;
}


if (mBluetoothDeviceAddress != null
	&& address.equals(mBluetoothDeviceAddress)
	&& mBluetoothGatt != null) {
if (mBluetoothGatt.connect()) {
	mConnectionState = STATE_CONNECTING;
	return true;
} else {
	return false;
		}
	}
final BluetoothDevice device = mBluetoothAdapter
	.getRemoteDevice(address);
if (device == null) {
	return false;
		}
mBluetoothGatt = device.connectGatt(this, AUTO_CONNECT, mGattCallback);
System.out.println("mBluetoothGatt");
mBluetoothDeviceAddress = address;
	
mConnectionState = STATE_CONNECTING;
return true;
	}


	/**
	 * 斷開GATT連接
	 */
private void disconnect() {
System.out.println("e");
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
	return;
	}
mBluetoothGatt.disconnect();
}


	/**
	 * GATT通信回調函數
	 */
@SuppressLint("NewApi")
private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {


		@Override
		
public void onCharacteristicChanged(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic) {
	// TODO Auto-generated method stub
	// super.onCharacteristicChanged(gatt, characteristic);
System.out.println("我收到的：" + new String(characteristic.getValue()));
	}


		@Override
public void onCharacteristicRead(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status) {
// TODO Auto-generated method stub
super.onCharacteristicRead(gatt, characteristic, status);
	}


		@Override
public void onCharacteristicWrite(BluetoothGatt gatt,
BluetoothGattCharacteristic characteristic, int status) {
// TODO Auto-generated method stub
super.onCharacteristicWrite(gatt, characteristic, status);
	}


		@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status,
	int newState) {
// TODO Auto-generated method stub
// super.onConnectionStateChange(gatt, status, newState);
if (newState == BluetoothProfile.STATE_CONNECTED) {
if (mBluetoothGatt != null)
mBluetoothGatt.discoverServices();
mConnectionState = STATE_CONNECTED;
System.out.println("state connected");
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
	// connect(mBluetoothDeviceAddress);
mConnectionState = STATE_DISCONNECTED;
System.out.println("state disconnected");
		}
	}


		@Override
public void onDescriptorRead(BluetoothGatt gatt,
BluetoothGattDescriptor descriptor, int status) {
// TODO Auto-generated method stub
super.onDescriptorRead(gatt, descriptor, status);
		}


		@Override
public void onDescriptorWrite(BluetoothGatt gatt,
BluetoothGattDescriptor descriptor, int status) {
// TODO Auto-generated method stub
super.onDescriptorWrite(gatt, descriptor, status);
		}


		@Override
public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
// TODO Auto-generated method stub
super.onReadRemoteRssi(gatt, rssi, status);
		}


		@Override
public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
// TODO Auto-generated method stub
	super.onReliableWriteCompleted(gatt, status);
		}


		@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
// TODO Auto-generated method stub
// super.onServicesDiscovered(gatt, status);		
if (status == BluetoothGatt.GATT_SUCCESS) {
if (mBluetoothGatt != null) {
BluetoothGattService mGattService = mBluetoothGatt
	.getService(SampleGattAttributes.UUID_SERVICE);
System.out.println("0");
		
mCharacteristic = mGattService
	.getCharacteristic(SampleGattAttributes.UUID_CHARACTERISTIC);
		
List<BluetoothGattDescriptor> mDescriptors = mCharacteristic.getDescriptors();
for (BluetoothGattDescriptor mDescriptor : mDescriptors) {
	System.out.println(mDescriptor.getUuid().toString());
			}
	setCharacteristicNotification(mCharacteristic,NOTIFICATION_ENABLED);
	wirteToBLE(testData);
	System.out.println(new String(readFromBLE()));
	wirteToBLE(testData);
	System.out.println(new String(readFromBLE()));
		}
		}
		}
		};
	
	/**
	 * 设置后可以使用通知 设备给手机发送通知时可触发onCharacteristicChanged()
	 * 
	 * @param characteristic
	 * @param enabled
	 */
private void setCharacteristicNotification(
BluetoothGattCharacteristic characteristic, boolean enabled) {
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
System.out.println("setCharacteristicNotification");
return;
  }
mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
BluetoothGattDescriptor descriptor = characteristic
.getDescriptor(SampleGattAttributes.UUID_DESCRIPTOR);
if (descriptor != null) {
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);
		}
	}
	
	/**
	 * 获取此实例
	 * 
	 * @return
	 */
public static BLEService self() {
	if (mContext != null)
	return (BLEService) mContext;
	return null;
	}

        /**
	 * 通信接口 通过此函数即可向BLE设备写入数据
	 * 
	 * @param value
	 * @return
	 */
public boolean wirteToBLE(byte[] value) {
System.out.println("f");
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
	Log.w(TAG, "BluetoothAdapter not initialized");
	return false;
		}
mCharacteristic.setValue(value);
boolean isSuccess = mBluetoothGatt.writeCharacteristic(mCharacteristic);
return isSuccess;
	}
	/**
	 * 通信接口 从BLE设备读数据
	 * 
	 * @return
	 */
public byte[] readFromBLE() {
	byte[] value = null;
	System.out.println("g");
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
			return null;
		}
boolean isSuccess = mBluetoothGatt.readCharacteristic(mCharacteristic);
if (isSuccess) {
value = mCharacteristic.getValue();
		}
return value;
	}           
          //-----Characteristics的字段信息-----//        
}


item_ble.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >


<TextView
        android:id="@+id/device_name"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="yuuyy88" 
        android:textSize="22sp"/>
</LinearLayout>



main.xml
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" > 
  <ListView
        android:id="@+id/list_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    </ListView>
 /FrameLayout>



meumrefresh.xml
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_height="wrap_content"  
    android:layout_width="56dp"  
    android:minWidth="56dp">  
   
    <ProgressBar android:layout_width="32dp"  
        android:layout_height="32dp"  
        android:layout_gravity="center"  
        style="?indeterminateProgressStyle" />  
</FrameLayout> 

main.xml
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context="com.example.ble.MainActivity" >


   
    <item android:id="@+id/menu_scan" 
        android:title="扫描" 
        android:layout_width="fill_parent"    
        android:layout_height="fill_parent" 
        />    
  
    <item android:id="@+id/menu_stop" 
        android:title="扫描停止" 
        android:layout_width="fill_parent"    
        android:layout_height="fill_parent" 
        />
        
    <item android:id="@+id/menu_refresh" 
        android:title="刷新扫描" 
        android:layout_width="fill_parent"    
        android:layout_height="fill_parent" 
        />
    
</menu>

    至此大部分代码已完成，还有部分定义常量的代码自行添加。还有请自行枚举出服务的UUID号然后添加到对应的代码中，否则程序会有问题。
    
    本文的思想方法来自于http://blog.youkuaiyun.com/zhaicaixiansheng/article/details/47070187；代码也主要来自于这篇博客；本文只是将他未贴出的部分代码完善而已。还请体谅作为一位新手的不易。
 


                

        

    

    
  



    



                



	

		

			

				
					
DA14531-浅谈用户建立BLE服务列表

				
			

			

				

					hejinwu1314的博客
				

				

					06-16
					
					292
					
				

			

		

		

			
				
用户在user_custs1_def.c和user_custs1_def.h定义BLE服务列表，这个两个文件组成一个模块，具体可以参见SDK文件，本文对这块进行解析并加以说明，旨在让读者加快对相关参数的理解，和建立BLE服务列表的认知，用户自身完成特定实例的修改。

			
		

	



                

            
              



	

		

			

				
					
【Android-通讯-蓝牙】你还不会 BLE？最全入门指南？

				
			

			

				

					QCODER's Coding Fleid
				

				

					01-22
					
					1400
					
				

			

		

		

			
				
目录

前言

通过蓝牙，我们能干嘛？

前言

在项目开发过程中，一般为了“快速开发”，我们一般除了CV，还有就是借轮子。这次蓝牙，我也借了一个轮子，但是这个轮子有问题？？

情况是这样的：在部分华为手机上使用App的蓝牙模块，会偶尔出现<针对性蓝牙服务缺失>。即：有一次手机A连上蓝牙在发现服务的时候，会缺失两个服务（其中一个是主要使用的服务），那么手机A再不做其他处理的情况下，就再也找不到那两个“丢失”的服务。但是，其他的手机又可以搜到该蓝牙设备对应的所有服务。碍于对轮子存在疑虑，于是...

			
		

	



              


  
              

                


	

		

			

				
					
BLE-hid report descriptor解析

				
			

			

				

					caicai6b6
				

				

					02-07
					
					3448
					
				

			

		

		

			
				
redsc文件
redsc 文件，反应的是按键的映射信息，获取这个文件大致有三个途径

hid 设备供应商提供相关设计规范文件，vendor spec
通过hci log 提取（本文以这个为例）
通过kernel log 提前（路径：sys/kernel/debug/hid/[device id]/redsc）, add device 阶段，bt 写到kernel 的，设备连接成功后，肯定会生成这...

			
		

	





	

		

			

				
					
Harmony Ble蓝牙App（四）描述符

					
最新发布

				
			

			

				

					晨曦
				

				

					01-20
					
					1533
					
				

			

		

		

			
				
上一篇中了解了特性和属性，同时显示设备蓝牙服务下的特性和属性，本文中就需要来使用这些特性和属性来完成一些功能。

			
		

	



		

			
		



	

		

			

				
					
BLE相关知识介绍

				
			

			

				

					realyouyi_的博客
				

				

					02-23
					
					1137
					
				

			

		

		

			
				
1.GAP概述

GAP 协议层定义了 BLE 设备的发现流程，设备管理和设备连接的建⽴。 BLE GAP 协议层采⽤ API 调⽤和事件 (Event) 返回的设计模式，通过事件返回来获取 API 在协议栈的处理结果。当对端设备主动发起请求时，也是通过事件返回获取对端设备的状态。BLE 设备定义了四类 GAP ⻆⾊：

• ⼴播者 (Broadcaster)：处于这种⻆⾊的设备通过发送⼴播 (Advertising) 让接收者发 现⾃⼰。这种⻆⾊只能发⼴播，不能被连接。

• 观察者 (Observer)

			
		

	





	

		

			

				
					
BLE 总结

				
			

			

				

					langwang2的专栏
				

				

					05-27
					
					3465
					
				

			

		

		

			
				
一：BLE相关概念概述 
1：相关概念 
Generic Attribute Profile (GATT) 
通过BLE连接，读写属性类小数据的Profile通用规范。现在所有的BLE应用Profile都是基于GATT的。 

Attribute Protocol (ATT) 
GATT是基于ATT Protocol的。ATT针对BLE设备做了专门的优化，具体就是在传输过程中使用尽量少

			
		

	





	

		

			

				
					
Ble蓝牙开发详解

				
			

			

				

					qq_36159785的博客
				

				

					04-24
					
					4829
					
				

			

		

		

			
				
蓝牙主要分为两种：经典蓝牙和低功耗蓝牙
Ble简介
低功耗蓝牙4.0只有android4.3或4.3以上才支持
1、BLE蓝牙4.0核心profile，主要特点是快速搜索，快速连接，超低功耗保持连接和数据传输，缺点：数据传输速率低，BLE蓝牙一包数据最多为20字节，因此安卓系统下最好不要使用BLE蓝牙传输大量数据，由于其具有低功耗特点，所以经常用在可穿戴设备之中。
2、Profile： 蓝牙规范，...

			
		

	





	

		

			

				
					
信息安全_浅谈BLE攻防.—lazydog.pptx

				
			

			

				

					08-14
				

			

		

		

			
				
【BLE技术概述】  BLE，全称为Bluetooth Low Energy，也被称为Bluetooth Smart，是一种低功耗的无线通信技术，广泛应用于智能设备和物联网(IoT)领域。它的设计目标是在保持较低能耗的同时提供稳定的数据传输，因此...

			
		

	





	

		

			

				
					
浅谈BLE(Bluetooth low enegy).pptx

				
			

			

				

					07-09
				

			

		

		

			
				
BLE LinkLayer层PPT讲义。主要讲述了LinkLayer的状态机，建立连接，报文报头，自适应跳频，连接参数更新等。

			
		

	





	

		

			

				
					
浅谈BLE协议栈

				
			

			

				

					aw的博客
				

				

					11-19
					
					1873
					
				

			

		

		

			
				
BLE 技术是 Bluetooth SIG 规定的一套通信协议，在协议变成具体的代码之前，都只存在文档中，TI、Nordic、CSR 等厂商，根据 SIG 发布的 BLE 技术协议，配合自身的芯片开发了一整套源码，并且这套源码经过了 SIG 的测试，服务 BLE 协议。这套源码就叫做协议栈，协议栈是协议的实现 
BLE协议层
PHY层（Physical layer物理层）
PHY层用来指定BLE所用的无线频段，调制解调方式和方法等。PHY层做得好不好，直接决定整个BLE芯片的功耗，灵敏度以及selectiv

			
		

	





	

		

			

				
					
浅谈Webpack核心模块tapable解析

				
			

			

				

					12-09
				

			

		

		

			
				
本文介绍了Webpack核心模块tapable，分享给大家，具体如下：  前言 Webpack 是一个现代 JavaScript 应用程序的静态模块打包器，是对前端项目实现自动化和优化必不可少的工具，Webpack 的 loader （加载器）和 plugin...

			
		

	





	

		

			

				
					
android ble缓冲区,Android BLE BluetoothGatt.writeDescriptor()有时会返回false

				
			

			

				

					weixin_34984235的博客
				

				

					05-27
					
					389
					
				

			

		

		

			
				
我正在尝试编写BLEAndroid应用程序.我发现有时当我打电话时BluetoothGatt.writeDescriptor()它返回false.我没有在文档中找到任何关于此功能的限制说明.但堆栈溢出的ppl说我需要等待BluetoothGattCallback.onDescriptorWrite()才能尝试写另一个描述符.这里有一个回复说BLE is busy用writeDescriptor()...

			
		

	





	

		

			

				
					
BLE 监听以及MTU浅析

				
			

			

				

					zolty
				

				

					07-12
					
					1852
					
				

			

		

		

			
				
监听
部分BLE程序会采用 descriptors 进行对固定UUID进行监听，例如：
“00002902-0000-1000-8000-00805f9b34fb”，这里采用了查找所有可用的descriptor UUID，对其监听
mInitialized = gatt.setCharacteristicNotification(characteristic, true);
//下面部分，不是必须的
Log.i(TAG,"setCharacteristicNotification : " + mInitia

			
		

	





	

		

			

				
					
Android BLE学习笔记

				
			

			

				

					逍遥游
				

				

					07-07
					
					1万+
					
				

			

		

		

			
				
1、概述
蓝牙无线技术是一种全球通用的短距离无线技术，通过蓝牙技术能够实现多种电子设备间的相互连接，特别是在小型无线电、耗电量低、成本低、安全性、稳定性、易用性以及特别的联网能力等固有的优势上，蓝牙无线技术发展迅速。
2、分类
蓝牙分为三种：Bluetooth Smart Ready、Bluetooth Smart（Smart是低功耗蓝牙的标识）、以及标准 Bluetooth。

			
		

	





	

		

			

				
					
Android BLE蓝牙4.0开发详解

				
			

			

				

					mengzhengjie的专栏
				

				

					08-05
					
					4104
					
				

			

		

		

			
				
http://blog.youkuaiyun.com/chenliqiang12345678/article/details/50504406





          这篇博客主要讲解 蓝牙 BLE 的用法。在讲解之前先讲一些概念性的东西，对于之前没接触过蓝牙开发，现在手上又有个蓝牙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的串口蓝牙模块。

			
		

	





	

		

			

				
					
Android   蓝牙BLE开发详解

				
			

			

				

					Charon1997的博客
				

				

					06-07
					
					1万+
					
				

			

		

		

			
				
Android   蓝牙BLE开发详解  有传输数据  多设备连接 获取uuid等

			
		

	





	

		

			

				
					
android  ble蓝牙开发略解

				
			

			

				

					woshasanguo的专栏
				

				

					11-13
					
					4万+
					
				

			

		

		

			
				
Android 蓝牙4.0开发
 
1、  权限和相关属性
“android:required="true"表示apk只有在具有bluetooth_le属性的系统里运行，这个4.3之前android系统没有

   


 
2、  程序开妈操作蓝牙之前，先判断ble是否支持
if(!getPackageManager().hasSystemFeature(PackageMan

			
		

	





	

		

			

				
					
android ble write,Android BLE BluetoothGatt.writeDescriptor()有时会返...

				
			

			

				

					weixin_35262602的博客
				

				

					05-27
					
					601
					
				

			

		

		

			
				
我正在尝试编写BLE Android应用程序.我发现有时当我打电话时BluetoothGatt.writeDescriptor()它返回false.我没有在文档中找到任何关于此功能的限制说明.但堆栈溢出的ppl说我需要等待BluetoothGattCallback.onDescriptorWrite()才能尝试写另一个描述符.这里有一个回复说BLE is busy用writeDescriptor(...

			
		

	





	

		

			

				
					
深入浅出BLE串口程序：轻松配置万能解决方案

				
			

			

				

					
				

			

		

		

			
				
BLE（Bluetooth Low Energy）即蓝牙低功耗技术，是蓝牙4.0版本引入的一种新的无线通信技术，主要用于短距离、低功耗的场景。BLE作为一种无线通信标准，拥有低功耗、成本低、广播能力强、通信安全等特点，非常适合于...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值