2. 程式人生 > >App 和裝置通過藍芽連線收發資料

App 和裝置通過藍芽連線收發資料

阿新 • • 發佈：2019-01-29

一、Android 中進行藍芽開發需要用到的類和執行過程

        1，使用BluetoothAdapter.startLeScance來掃描裝置

     2，在掃描到裝置的回撥函式中的得到BluetoothDevice 物件，並使用Bluetooth.stopLeScan停止掃描

     3，使用BluetoothDevice.connectGatt來獲取到BluetoothGatt物件

     4，執行BluetoothGatt.discoverServices，這個方法是非同步操作，在回撥函式onServicesDiscovered中得到status，通過判斷status是否等於BluetoothGatt.GATT_SUCCESS來            判斷查詢Service是否成功

     5，如果成功了，則通過BluetoothGatt.getService來獲取BluetoothGattService

     6，接著通過BluetoothGattService.getCharacteristic獲取BluetoothGattCharacteristic

     7，然後通過BluetoothGattCharacteristic.getDescriptor獲取BluetoothGattDescriptor

二、收發資料

      收發資料是通過GATT，GATT是通過藍芽收發資料的一種協議，包含Characteristic,Descriptor,Service 三個屬性值，BLE 分為三個部分Service , Characteristic ,Descriptor  這三個部分都是由UUID做為唯一的識別符號，一個藍芽終端可以包含多個Service ，一個Service 可以包含多個Characteristic ,一個Characteristic 包含一個Value 和多個Descriptor,一個Descriptor包含一個Value

三、上程式碼（有些工具類是在其他檔案裡面，我這裡沒有在改了，直接複製上來了）

MainActivice.java：

BluetoothManager bluetoothManager;
BluetoothAdapter mBluetoothAdapter;
Intent intentBluetoothLeService = new Intent();
//低功耗藍芽的檔名
public static String BLUETOOTHSERVICE = "com.boe.navapp.remote.BluetoothLeService";

bluetoothManager = (BluetoothManager) MainActivity.this

 
.getSystemService(Context.BLUETOOTH_SERVICE);
mBluetoothAdapter = bluetoothManager.getAdapter();
if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
    if (!(CommonUtil.isServiceRunning(MainActivity.this,
            Constants.BLUETOOTHSERVICE))) {
        intentBluetoothLeService = new Intent(MainActivity.this,
                BluetoothLeService.class);
        startService(intentBluetoothLeService);
    }
}
// 判斷當前服務是否啟動
public static boolean isServiceRunning(Context mContext, String className) {
    boolean isRunning = false;
    ActivityManager activityManager = (ActivityManager) mContext
            .getSystemService(Context.ACTIVITY_SERVICE);
    List<ActivityManager.RunningServiceInfo> serviceList = activityManager
            .getRunningServices(70);
    if (!(serviceList.size() > 0)) {
        return false;
    }
    for (int i = 0; i < serviceList.size(); i++) {
        if (serviceList.get(i).service.getClassName().equals(className) == true) {
            isRunning = true;
            break;
        }
    }
    return isRunning;
}


BluetoothLeService.java:(這裡我講下主要程式碼，檔案我會傳上去)

public final static String REMOTE_CONNECT_STATUS = "REMOTE_CONNECT_STATUS";// 當前選擇的遙控器連線狀態
public final static String REMOTE_CONNECTED_DEVICES = "REMOTECONNECTEDDEVICES";// 儲存已經連線的裝置列表
public final static String REMOTE_DEVICE_INFO = "REMOTEDEVICEINFO";
public final static String REMOTE_CURR_ADDR = "REMOTECURRADDR";// 當前連線裝置的地址
public final static String ACTION_GATT_REMOTESEVEN_DISCONNECTED = "com.infisight.hudprojector.bluetooth.le.ACTION_GATT_REMOTESEVEN_DISCONNECTED";
private static final String SP_NAME = "address";
@Override
public void onCreate() {
    super.onCreate();
    LogTools.i(TAG, "BluetoothLeService onCreate");
    prefs = PreferenceManager.getDefaultSharedPreferences(this);
    telMgr = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
    prefs.edit().putBoolean(Constants.REMOTE_CONNECT_STATUS, false)
            .commit();
    LogTools.i(TAG, "BluetoothLeService before SaveUtils.loadArray");
    addressList = SaveUtils.loadArray(this, SP_NAME);  //存放連線的地址
GetDeviceInfo();
    LogTools.i(TAG, "BluetoothLeService GetDeviceInfo");
}

/**
 * 獲取裝置資訊 lstNeedConnectDevices
 */
private void GetDeviceInfo() {
    String connectedinfo = prefs.getString(
            Constants.REMOTE_CONNECTED_DEVICES, "");
    if (!connectedinfo.equals("")) {
        Gson gson = new Gson();
        try {
            lstNeedConnectDevices = gson.fromJson(connectedinfo,
                    new TypeToken<List<BleConnectDevice>>() {
                    }.getType());
            for (BleConnectDevice bleconnectdevice : lstNeedConnectDevices) {
                if (!lstNeedConnectAddress.contains(bleconnectdevice
                        .getAddress()))
                    lstNeedConnectAddress
.add(bleconnectdevice.getAddress());
            }
        } catch (Exception e) {
        }
    }
}

public boolean initialize() {
    // 獲取藍芽管理
if (mBluetoothManager == null) {
        mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
        if (mBluetoothManager == null) {
            return false;
        }
    }
    // 獲取介面卡
mBluetoothAdapter = mBluetoothManager.getAdapter();
    return mBluetoothAdapter != null;
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    LogTools.d(TAG, "onStartCommand:flags=" + flags + ",startId=" + startId);
    if (mBluetoothManager == null) {
        if (!initialize()) {
            LogTools.i(TAG, "Unable to initialize Bluetooth");
        }
    }
    if (isFirstRun) {
        try {
            handler.postDelayed(runnable, 2000);
        } catch (Exception e) {
        }
    } else {
        LogTools.i(TAG, "Constants.REMOTE_DEVICE_INFO:");
        String address = getSharedPreferences(Constants.REMOTE_DEVICE_INFO,
                0).getString(Constants.REMOTE_CURR_ADDR, "0");
        connect(address);
    }
    isFirstRun = false;
    return START_STICKY;
}

/**
 * 啟動連線執行緒
 */
Runnable runnable = new Runnable() {
    @Override
public void run() {
        // 在這裡啟動連線，如果連線失敗，就再重新試圖連線
LogTools.i(TAG, "try connect runnable");
        try {
            mBluetoothAdapter.stopLeScan(mLeScanCallback);
            mBluetoothAdapter.startLeScan(mLeScanCallback); //掃描低功耗藍芽裝置
} catch (Exception e) {
            // TODO Auto-generated catch block
LogTools.i(TAG, "try connect runnable failed:" + e.getMessage());
            e.printStackTrace();
        }
        handler.postDelayed(this, 10000);
    }

};

// 裝置查找回調得到BluetoothDevice物件
LeScanCallback mLeScanCallback = new LeScanCallback() {

    @Override
public void onLeScan(final BluetoothDevice device, int rssi,
                         byte[] scanRecord) {
        LogTools.d(TAG, "device.getName:" + device.getName() + ",device.address:" + device.getAddress());
        if ("KeyCtrl".equals(device.getName())) {
            close(mGattMap.get(device.getAddress()));

            //獲取BluetoothGatt 物件
BluetoothGatt mBluetoothGatt = device.connectGatt(
                    BluetoothLeService.this, false, mGattCallback);
            mGattMap.put(device.getAddress(), mBluetoothGatt);
        } else if ("infisight_r".equals(device.getName()))//對藍芽OBD功能進行連線
{
            try {
                close(mGattMap.get(device.getAddress()));
                BluetoothGatt mBluetoothGatt = device.connectGatt(
                        BluetoothLeService.this, false, mGattCallback);
                mGattMap.put(device.getAddress(), mBluetoothGatt);
            } catch (Exception e) {
                LogTools.e(TAG, "mBluetoothGatt failed:" + e.getMessage());
            }
        }

    }
};

    private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {

        @Override
public void onConnectionStateChange(BluetoothGatt gatt, int status,
                                            int newState) {
            // 連線狀態發生變更
String intentAction = Constants.ACTION_GATT_REMOTESEVEN_DISCONNECTED;
            LogTools.e(TAG, "onConnectionStateChange:name:" + gatt.getDevice().getName() + "Addr:" + gatt.getDevice().getAddress() + ",newState:" + newState);
            if (newState == BluetoothProfile.STATE_CONNECTED) {
                hmIsConnected.put(gatt.getDevice().getAddress(), true);
                SaveUtils.saveArray(BluetoothLeService.this, SP_NAME,
                        addressList);
                if ("KeyCtrl".equals(gatt.getDevice().getName())) {
                    intentAction = Constants.ACTION_GATT_REMOTE_CONNECTED;
                } else if ("infisight_r".equals(gatt.getDevice().getName())) {
                    LogTools.e(TAG, "ble ACTION_GATT_REMOTE_CONNECTED");
                    intentAction = Constants.ACTION_GATT_REMOTESEVEN_CONNECTED;
                }
                prefs.edit().putBoolean(Constants.REMOTE_CONNECT_STATUS, true)
                        .commit();
                broadcastUpdate(intentAction);
                LogTools.e(TAG, "ble gatt.discoverServices");
                gatt.discoverServices();
                SaveDeviceInfo(gatt.getDevice());
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                LogTools.d(TAG, "BluetoothProfile.STATE_DISCONNECTED");
                // 開啟執行緒，不斷時的試圖連線裝置
hmIsConnected.put(gatt.getDevice().getAddress(), false);
                if ("KeyCtrl".equals(gatt.getDevice().getName())) {
                    intentAction = Constants.ACTION_GATT_REMOTE_DISCONNECTED;
                } else if ("infisight_r".equals(gatt.getDevice().getName())) {
                    LogTools.d(TAG, "BLE BluetoothProfile.STATE_DISCONNECTED");
                    intentAction = Constants.ACTION_GATT_REMOTESEVEN_DISCONNECTED;
                }
                prefs.edit().putBoolean(Constants.REMOTE_CONNECT_STATUS, false)
                        .commit();
//                close(gatt);
disconnect(gatt);
                broadcastUpdate(intentAction);
            }
        }

        //通過status 是否等於BluetoothGatt.GATT_SUCCESS來判斷查詢Service是否成功
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            // 發現服務的廣播
LogTools.e(TAG, "onServicesDiscovered:" + gatt.getDevice().getAddress());
            if (status == BluetoothGatt.GATT_SUCCESS) {
                displayGattServices(getSupportedGattServices(gatt), gatt);
                broadcastUpdate(Constants.ACTION_GATT_SERVICES_DISCOVERED);

            }
        }

        @Override
public void onCharacteristicRead(BluetoothGatt gatt,
                                         BluetoothGattCharacteristic characteristic, int status) {
            LogTools.d(TAG, "onCharacteristicRead");
            if (status == BluetoothGatt.GATT_SUCCESS) {
                broadcastUpdate(Constants.ACTION_DATA_AVAILABLE, gatt, characteristic);
            }
        }

        @Override
public void onCharacteristicChanged(BluetoothGatt gatt,
                                            BluetoothGattCharacteristic characteristic) {
            LogTools.d(TAG, "onCharacteristicChanged");
            broadcastUpdate(Constants.ACTION_DATA_AVAILABLE, gatt, characteristic);
        }

        @Override
public void onCharacteristicWrite(BluetoothGatt gatt,
                                          BluetoothGattCharacteristic characteristic, int status) {

        }
    };
 public static boolean saveArray(Context context, String spname, ArrayList<String> list) {
        mySharedPreferences = context.getSharedPreferences(spname, Context.MODE_PRIVATE);
        Editor edit = mySharedPreferences.edit();
        edit.putInt("Status_size", list.size()); /*sKey is an array*/
for (int i = 0; i < list.size(); i++) {
            edit.putString("Status_" + i, list.get(i) + "");
        }
//     LogTools.i("saveArray", list+"");
return edit.commit();
    }
  private void broadcastUpdate(final String action) {
        final Intent intent = new Intent(action);
        sendBroadcast(intent);
    }

/**
     * 儲存裝置資訊
     */
private void SaveDeviceInfo(BluetoothDevice bluetoothdevice) {
        List<BleConnectDevice> lstConnectDevices = new ArrayList<BleConnectDevice>();
        String connectedinfo = prefs.getString(
                Constants.REMOTE_CONNECTED_DEVICES, "");
        Gson gson = new Gson();
        if (!connectedinfo.equals("")) {

            try {
                lstConnectDevices = gson.fromJson(connectedinfo,
                        new TypeToken<List<BleConnectDevice>>() {
                        }.getType());
            } catch (Exception e) {
            }
        }
        if (!lstNeedConnectAddress.contains(bluetoothdevice.getAddress())) {
            lstNeedConnectAddress.add(bluetoothdevice.getAddress());
            BleConnectDevice bledevice = new BleConnectDevice(); //儲存裝置的資訊
bledevice.setAddress(bluetoothdevice.getAddress());
            bledevice.setName(bluetoothdevice.getName());
            lstConnectDevices.add(bledevice);
            try {
                String newaddr = gson.toJson(lstConnectDevices);
                prefs.edit()
                        .putString(Constants.REMOTE_CONNECTED_DEVICES, newaddr)
                        .commit();
            } catch (Exception e) {
            }
        } else if ("KeyCtrl".equals(bluetoothdevice.getName())) {
            mTypeMap.put(bluetoothdevice.getAddress(), "remote");
//        }else  if (bluetoothdevice.getName().contains("BLE"))//對藍芽OBD功能進行連線
} else if ("infisight_r".equals(bluetoothdevice.getName()))//對藍芽OBD功能進行連線
{
            mTypeMap.put(bluetoothdevice.getAddress(), "remote");
        }

    }
  public boolean connect(final String address) {
        // 確認已經獲取到介面卡並且地址不為空
if (mBluetoothAdapter == null || address == null || address.equals("0")) {
            return false;
        }

        final BluetoothDevice device = mBluetoothAdapter
.getRemoteDevice(address);
        // 通過裝置地址獲取裝置
if (device == null) {
            LogTools.e(TAG, "Device not found.  Unable to connect.");
            return false;
        }
        // LogTools.i(TAG, "device.connectGatt(this, false, mGattCallback)");
if (mGattMap.keySet().contains(address)) {
            BluetoothGatt mBluetoothGatt = mGattMap.get(address);
            if (mBluetoothGatt != null) {
                // close(mBluetoothGatt);
disconnect(mBluetoothGatt);
            }
        }
        BluetoothGatt mBluetoothGatt = device.connectGatt(this, false,
                mGattCallback);
        mGattMap.put(address, mBluetoothGatt);
        addressList.add(address);
//        mConnectionState = STATE_CONNECTING;
return true;
    }

public void disconnect(BluetoothGatt mBluetoothGatt) {
    // LogTools.i("LIFECYCLE", "disconnect");
if (mBluetoothAdapter == null || mBluetoothGatt == null) {
        LogTools.e(TAG, "BluetoothAdapter not initialized disconnect");
        return;
    }
    mBluetoothGatt.disconnect();
    // 斷開連線
}


  // 從特徵中分析返回的資料並表示為action後進行廣播
private void broadcastUpdate(final String action, BluetoothGatt gatt,
                                 final BluetoothGattCharacteristic characteristic) {
        if ("KeyCtrl".equals(gatt.getDevice().getName())) {
            final byte[] data = characteristic.getValue();
            if (data != null && data.length > 0) {
                final StringBuilder stringBuilder = new StringBuilder(data.length);
                for (byte byteChar : data)
                    stringBuilder.append(String.format("%02X ", byteChar));
                if (stringBuilder.toString().trim().equals("01")) {
                    // 上
int operFlag = 1;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
                    LogTools.i(TAG, "keys01");

                } else if (stringBuilder.toString().trim().equals("02")) {
                    LogTools.i(TAG, "isPhoneIng："+ProcessMsgService.isPhoneIng);
                    if(ProcessMsgService.isPhoneIng == true)
                    {
                        try {
                            PhoneUtils.getITelephony(telMgr)
                                    .answerRingingCall();
                        } catch (RemoteException e) {
                            // TODO Auto-generated catch block
e.printStackTrace();
                        } catch (Exception e) {
                            LogTools.i(TAG, "error："+e.getMessage());
                            CommonUtil.answerRingingCall(this);
                        }
                        return;
                    }
                    // 確定
int operFlag = 5;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_SINGLETAP);
LogTools.i(TAG, "keys02");
                } else if (stringBuilder.toString().trim().equals("04")) {
                    // 喚醒
MainActivity.svr.controlToWake(true);
                    LogTools.i(TAG, "keys04");
                } else if (stringBuilder.toString().trim().equals("08")) {
                    LogTools.i(TAG, "isPhoneIng："+ProcessMsgService.isPhoneIng);
                    LogTools.i(TAG, "keys08");
                    if(ProcessMsgService.isPhoneIng == true)
                    {
                        try {
                            PhoneUtils.getITelephony(telMgr).endCall();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    // 返回
int operFlag = 0;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GETSTURE_BACK);
LogTools.i(TAG, "keys08");
                } else if (stringBuilder.toString().trim().equals("10")) {
                    // 下
int operFlag = 2;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_TODOWN);
LogTools.i(TAG, "keys10");
                }
                // intent.putExtra(EXTRA_DATA, new String(data) + "\n" +
                // stringBuilder.toString());
}
//        }else if (gatt.getDevice().getName().contains("BLE"))
} else if ("infisight_r".equals(gatt.getDevice().getName())) {
            final byte[] data = characteristic.getValue();
            if (data != null && data.length > 0) {
                final StringBuilder stringBuilder = new StringBuilder(data.length);
                for (byte byteChar : data)
                    stringBuilder.append(String.format("%02X ", byteChar));
                if (stringBuilder.toString().trim().equals("15")) {
                    // 上
int operFlag = 1;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();

                } else if (stringBuilder.toString().trim().equals("12")) {
                    //如果在通話中，接聽電話
if(ProcessMsgService.isPhoneIng == true)
                    {
                        try {
                            PhoneUtils.getITelephony(telMgr)
                                    .answerRingingCall();
                        } catch (RemoteException e) {
                            // TODO Auto-generated catch block
e.printStackTrace();
                        } catch (Exception e) {
                            CommonUtil.answerRingingCall(this);
                        }
                        return;
                    }
                    // 確定
int operFlag = 5;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_SINGLETAP);
} else if (stringBuilder.toString().trim().equals("14")) {
                    // 喚醒
MainActivity.svr.controlToWake(true);
                } else if (stringBuilder.toString().trim().equals("16")) {
                    //如果已經在通話中，直接結束通話電話
LogTools.i(TAG, "key：16");
                    LogTools.i(TAG, "isPhoneIng："+ProcessMsgService.isPhoneIng);
                    if(ProcessMsgService.isPhoneIng == true)
                    {
                        try {
                            PhoneUtils.getITelephony(telMgr).endCall();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    // 返回
int operFlag = 0;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GETSTURE_BACK);
} else if (stringBuilder.toString().trim().equals("11")) {
                    // 下
int operFlag = 2;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_TODOWN);
} else if (stringBuilder.toString().trim().equals("13")) {
                    // 左
int operFlag = 3;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_TOLEFT);
} else if (stringBuilder.toString().trim().equals("17")) {
                    // 右
int operFlag = 4;
                    Message msg = sendKeyHandler.obtainMessage(operFlag);
                    msg.what = operFlag;
                    msg.sendToTarget();
//          ProcessBroadcast(Constants.GESTURE_INFO,
//                Constants.GESTURE_TORIGHT);
}
            }
        }

    }

BluetoothService 下載地址http://download.csdn.net/detail/pigseesunset/9690371

相關推薦

App 和裝置通過藍芽連線收發資料

一、Android 中進行藍芽開發需要用到的類和執行過程         1，使用BluetoothAdapter.startLeScance來掃描裝置      2，在掃描到裝置的回撥函式中的得到BluetoothDevice 物件，並使用Bluetooth.stopLe

用AppInventor自制app通過藍芽與pyboard nano做通訊(上)

** 用AppInventor自制app通過藍芽與pyb nano做通訊(上) ** App Inventor 原是Google實驗室（Google Lab）的一個子計劃，由一群Google工程師和勇於挑戰的Google使用者共同參與設計完成。Google Ap

樹莓派3命令列配置wifi無線連線和藍芽連線

樹莓派(raspberry pi)在3月份更新了，新的樹莓派3內建wifi和藍芽，再也不用usb介面卡了，到手後第一步當然是測試藍芽和wifi,不然買到2冒充的就傻眼了，本文介紹在命令列裡啟用wifi連線和藍芽連線。 個人原創，版權所有，轉載請註明原文出處，並保留原文

iOS藍芽開發：藍芽連線和資料讀寫

當下藍芽開發可謂是越來越火，不論是智慧穿戴的興起還是藍芽傢俱，車聯網藍芽等等，很多同學也會接觸到藍芽的專案，我從事藍芽開發也有一段時間了，經手了兩個專案。廢話不多說了，先向大家簡單的介紹有關藍芽開發的知識。藍芽低能耗(BLE)，以下介紹的都是圍繞iOS的框架展開

mac通過藍芽抓包分析iPhone app網路請求

在遊戲或者手機app開發過程中，前後端為了除錯定位協議問題，有時候需要抓取客戶端伺服器的網路互動資料包進行分析。在linux伺服器上可以方便的在命令列使用tcpdump抓包，在windows或者mac上 也可以選擇Wireshark，Ethereal等工具。

用Android手機通過藍芽模組HC-06連線Arduino串列埠輸出

通過手機進行通訊是可以實現很多遙控功能，雖然距離是比較短，一般是10米，但對於我這種新手做測試，比起買一個幾百塊的多通道遙控器成本要低很多。實驗目的：用Android實現藍芽連線通過Arduino串列埠輸出資訊這次使用的是藍芽HC-06從模組，就是從機模組，這都因為買之前沒有

IOS藍芽連線和傳送資料

首先要確定藍芽是否開啟 本文使用的是 Objective-C語言 1.新建一個藍芽幫助類BlueHelp 並匯入 pragma mark - CBPeripheralDelegate //只要掃描到服務就會呼叫,其中的外設就是服務所在的外設 - (

Android手機通過藍芽向目標裝置（ble）傳輸訊息

最近一直在研究兩個手機用過藍芽通訊，參考了部分網上程式碼，到最後也沒弄清楚。（樓主是學渣......）然後有一個專案要用手機通過藍芽控制三色燈，我就隨意寫了一下客戶端的應用程式，而且沒有測試，通過部落格記錄一下方便以後使用測試。閒話不多說。開始----參考部分網上程式碼：附上

Android智慧裝置藍芽連線(BLE)

智慧裝置BLE 藍芽裝置 目前藍芽功能應用更多是在智慧裝置方面使用，用於連線智慧裝置與硬體，並且能夠實現裝置與硬體之間的通訊，向硬體傳送資料並接收硬體向外傳遞資料。達到獲取硬體狀態或者控制硬體執行的需求。 藍芽搜尋 獲取藍芽Adapter,用於藍

樹莓派2model B 通過藍芽實現A2DP協議連線手機播放音樂

使用樹莓派，開啟他的A2DP功能，實現用手機藍芽控制樹莓派播放歌曲。主要操作過程參考http://wangye.org/blog/archives/921/以及英文部落格http://www.instructables.com/id/Turn-your-Raspberry-

Android APP通過藍芽耳機錄音可行性分析

1 藍芽的兩種型別 部署最為普遍的兩種規格為藍芽基礎率/增強資料率 (BR/EDR)（採用版本為 2.0/2.1）和低耗能 (LE) 藍芽（採用版本為 4.0/4.1/4.2）。 存在哪些差異？ 藍芽 BR/EDR—可建立相對較短距離的持續無線連線，因此非

一分鐘讀懂低功耗藍芽連線資料包

一分鐘讀懂低功耗藍芽（BLE)連線資料包1.概述   BLE 連線過程中有三個重要的資料包：SCAN_REQ, SCAN_RSP 和 CONNECT_REQ。   SCAN_REQ： 掃描請求，由主裝置（MASTER DEVICE）向從裝置（SLAVE DEV

微信小程式-藍芽連線

最近的專案需要使用小程式的藍芽功能與硬體裝置進行連線相互傳送資料指令，聯調過程中發現一些問題，於是想著記錄下來，方便以後檢視！ 1.0一般使用藍芽功能肯定是想連線某一個藍芽裝置，所以需要知道這個藍芽裝置的名稱，一般來說都是掃描二維碼連線，那麼當你掃描這個裝置二維碼的時候，就需要去初始化你手機上的藍芽模組了

Android 藍芽連線之 A2dp

      A2DPProfile  定義了高質量音訊資料傳輸的協議和過程，包括立體聲和單聲道資料的傳輸。這裡的高質量音訊指的是單聲道(Mono)和立體聲(Sterco)  的音訊，主要區別於藍牙  SCO  鏈路上傳輸的普通語音。A2DP  的典型應用是將音樂播放器的音訊資

Thinkpad E431 藍芽連線問題

最近新入了藍芽耳機，之前連電腦一直是有線，平時傳檔案也是用微信或者QQ或者直接有線連上電腦完成對手機檔案的管理，所以一直沒有使用過電腦的藍芽功能。結果今天一試發現E431的藍芽功能居然用不了，具體表現為： 我首先是開了手機藍芽做傳輸檔案的嘗試，實際上，電腦和手機已經配對，並

【Android開發 藍芽連線狀態】Android實時檢測藍芽連線狀態

http://blog.csdn.net/dengpeng0419/article/details/53178730 本程式能實時監聽並檢測Android藍芽的連線狀態，無論是通過介面上的switch按鈕開啟/關閉手機藍芽，還是手動開啟/關閉手機藍芽，程式都能監聽當前的狀態

關於經典藍芽和低功耗藍芽的區別

Android中的藍芽開發要說到藍芽，小夥伴們聽到的可能有藍芽1.0、藍芽2.0、藍芽3.0、藍芽4.0之類的以數字結尾的藍芽版本號，而實際上，在最新的標準中，已經不再使用數字版本號作為藍芽版本的區分了，取而代之的是經典藍芽與低功耗藍芽（BLE）這兩種區別。這裡

微信小程式藍芽連線傳送資訊

///獲取應用例項 var app = getApp() Page({ data: { lanya: "", state: "", msg: "", sousuo: "", status: "", connectedDeviceId: "",//連線裝置Id

Android開發之通過藍芽耳機實現訊飛語音識別的功能

近階段在開發一款app，實現通過藍芽耳機進行訊飛語音識別，獲取識別結果之後再通過語音合成從藍芽耳機播報出識別結果。上網也查了很多資料，大多是說通過一下兩行程式碼：      mAudioManager.setBluetoothScoOn(true);           

android wear那些事--通過藍芽除錯

你可以通過藍芽除錯手錶應用,除錯資訊會輸出到連線配對的手機上. 設定進行除錯 在手機上開啟USB除錯 1.開啟設定>關於手機,連續點選版本號7次開啟開發者選項. 2.設定>開發者選項,開啟USB除錯. 在手錶上開啟藍芽除錯 1