2016-10-21 8 views
0

私は誰も助けてください、私はすでに多くの方法を試してみました。 BluetoothGatt mBluetoothGatt false.Iは、このための正しいマニュアルを見つけることが、明確なBEL用のサンプルandroid.`
パッケージcom.example.android.bluetoothlegattがなかった多くの方法を試したことができませんでした mBluetoothGatt.writeCharacteristic(mWriteCharacteristic) リターン真 しかしreadCharacteristic(BluetoothGattCharacteristic characteristic)リターン。BLE書き込みと問題の読み取り?

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.os.Binder; 
import android.os.IBinder; 
import android.util.Log; 

import java.io.UnsupportedEncodingException; 
import java.net.URLEncoder; 
import java.util.List; 
import java.util.UUID; 

import static com.example.android.bluetoothlegatt.DeviceControlActivity.hexArray; 

public class BluetoothLeService extends Service { 
    private final static String TAG = BluetoothLeService.class.getSimpleName(); 

    private BluetoothManager mBluetoothManager; 
    private BluetoothAdapter mBluetoothAdapter; 
    private String mBluetoothDeviceAddress; 
    private BluetoothGatt mBluetoothGatt; 
    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; 

    public final static String ACTION_GATT_CONNECTED = 
      "com.example.bluetooth.le.ACTION_GATT_CONNECTED"; 
    public final static String ACTION_GATT_DISCONNECTED = 
      "com.example.bluetooth.le.ACTION_GATT_DISCONNECTED"; 
    public final static String ACTION_GATT_SERVICES_DISCOVERED = 
      "com.example.bluetooth.le.ACTION_GATT_SERVICES_DISCOVERED"; 
    public final static String ACTION_DATA_AVAILABLE = 
      "com.example.bluetooth.le.ACTION_DATA_AVAILABLE"; 
    public final static String EXTRA_DATA = 
      "com.example.bluetooth.le.EXTRA_DATA"; 

    public final static UUID UUID_HEART_RATE_MEASUREMENT = 
      UUID.fromString(SampleGattAttributes.HEART_RATE_MEASUREMENT); 
    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; 
       broadcastUpdate(intentAction); 
       Log.i(TAG, "Connected to GATT server."); 
       Log.i(TAG, "Attempting to start service discovery:" + 
         mBluetoothGatt.discoverServices()); 

      } 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) { 
       broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED); 
      } else { 
       Log.w(TAG, "onServicesDiscovered received: " + status); 
      } 
     } 

     @Override 
     public void onCharacteristicRead(BluetoothGatt gatt, 
             BluetoothGattCharacteristic characteristic, 
             int status) { 
      Log.i(TAG,"onCharacteristicRead::"+status); 
      if (status == BluetoothGatt.GATT_SUCCESS) { 


       broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic); 

      } 
     } 

     @Override 
     public void onCharacteristicChanged(BluetoothGatt gatt, 
              BluetoothGattCharacteristic characteristic) { 
      Log.i(TAG,"onCharacteristicChanged::"+characteristic); 
      broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic); 
     } 

     @Override 
     public void onCharacteristicWrite(final BluetoothGatt gatt, final BluetoothGattCharacteristic characteristic, int status) { 
      super.onCharacteristicWrite(gatt, characteristic, status); 
      byte[] data = characteristic.getValue(); 
      Log.i(TAG,"onCharacteristicWrite Response::"+bytesToHex(data)); 
     } 

    }; 

    public static String bytesToHex(byte[] bytes) { 
     char[] hexChars = new char[bytes.length * 2]; 
     for (int j = 0; j < bytes.length; j++) { 
      int v = bytes[j] & 0xFF; 
      hexChars[j * 2] = hexArray[v >>> 4]; 
      hexChars[j * 2 + 1] = hexArray[v & 0x0F]; 
     } 
     return new String(hexChars); 
    } 

    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); 
     if (UUID_HEART_RATE_MEASUREMENT.equals(characteristic.getUuid())) { 
      int flag = characteristic.getProperties(); 
      int format = -1; 
      if ((flag & 0x01) != 0) { 
       format = BluetoothGattCharacteristic.FORMAT_UINT16; 
       Log.d(TAG, "Heart rate format UINT16."); 
      } else { 
       format = BluetoothGattCharacteristic.FORMAT_UINT8; 
       Log.d(TAG, "Heart rate format UINT8."); 
      } 
      final int heartRate = characteristic.getIntValue(format, 1); 
      Log.d(TAG, String.format("Received heart rate: %d", heartRate)); 
      intent.putExtra(EXTRA_DATA, String.valueOf(heartRate)); 
     } else { 
      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)); 
       intent.putExtra(EXTRA_DATA, new String(data) + "\n" + stringBuilder.toString()); 
      } 
     } 
     sendBroadcast(intent); 
    } 

    public class LocalBinder extends Binder { 
     BluetoothLeService getService() { 
      return BluetoothLeService.this; 
     } 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 
     return mBinder; 
    } 

    @Override 
    public boolean onUnbind(Intent intent) { 
     close(); 
     return super.onUnbind(intent); 
    } 

    private final IBinder mBinder = new LocalBinder(); 


    public boolean initialize() { 
     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; 
     } 

     return true; 
    } 


    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; 
     return true; 
    } 
    public void disconnect() { 
     if (mBluetoothAdapter == null || mBluetoothGatt == null) { 
      Log.w(TAG, "BluetoothAdapter not initialized"); 
      return; 
     } 
     mBluetoothGatt.disconnect(); 
    } 
    public void close() { 
     if (mBluetoothGatt == null) { 
      return; 
     } 
     mBluetoothGatt.close(); 
     mBluetoothGatt = null; 
    } 
    public void readCharacteristic(BluetoothGattCharacteristic characteristic) { 
     if (mBluetoothAdapter == null || mBluetoothGatt == null) { 
      Log.w(TAG, "BluetoothAdapter not initialized"); 
      return; 
     } 
     mBluetoothGatt.readCharacteristic(characteristic); 
    } 
    public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic, 
               boolean enabled) { 
     if (mBluetoothAdapter == null || mBluetoothGatt == null) { 
      Log.w(TAG, "BluetoothAdapter not initialized"); 
      return; 
     } 
     mBluetoothGatt.setCharacteristicNotification(characteristic, enabled); 
     if (UUID_HEART_RATE_MEASUREMENT.equals(characteristic.getUuid())) { 
      BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
        UUID.fromString(SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG)); 
      descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE); 
      mBluetoothGatt.writeDescriptor(descriptor); 
     } 
    } 
    public List<BluetoothGattService> getSupportedGattServices() { 
     if (mBluetoothGatt == null) return null; 

     return mBluetoothGatt.getServices(); 
    } 

    public void readCustomCharacteristic() { 
     if (mBluetoothAdapter == null || mBluetoothGatt == null) { 
      Log.w(TAG, "BluetoothAdapter not initialized"); 
      return; 
     } 
     BluetoothGattService mCustomService = mBluetoothGatt.getService(UUID.fromString("0000bc01-0000-1000-8000-00805f9b34fb")); 
     if(mCustomService == null){ 
      Log.w(TAG, "Custom BLE Service not found"); 
      return; 
     } 
     BluetoothGattCharacteristic mReadCharacteristic = mCustomService.getCharacteristic(UUID.fromString("0000bd01-0000-1000-8000-00805f9b34fb")); 
     UUID uuid = UUID.fromString("00002901-0000-1000-8000-00805f9b34fb"); 
     Log.i(TAG,"BluetoothGattCharacteristic Des::"+mReadCharacteristic.getDescriptor(uuid)); 
     BluetoothGattDescriptor descriptor = mReadCharacteristic.getDescriptor(uuid); 
     Log.i(TAG,"BluetoothGattDescriptor is::"+descriptor.getUuid()); 
     descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE); 
     mBluetoothGatt.writeDescriptor(descriptor); 
     mBluetoothGatt.setCharacteristicNotification(mReadCharacteristic, true); 
     mReadCharacteristic = mCustomService.getCharacteristic(UUID.fromString("0000bd01-0000-1000-8000-00805f9b34fb")); 

     byte[] data = mReadCharacteristic.getValue(); 
     Log.i(TAG,"onCharacteristicWrite Response::"+bytesToHex(data)); 
     if(mBluetoothGatt.readCharacteristic(mReadCharacteristic) == false) { 
      Log.w(TAG, "Failed to read characteristic"); 
     } 
     else{ 
      Log.w(TAG, "Suucess to read characteristic"); 
      mBluetoothGatt.notify(); 
     } 
    } 
    public void writeCustomCharacteristic(byte value[]) { 
     if (mBluetoothAdapter == null || mBluetoothGatt == null) { 
      Log.w(TAG, "BluetoothAdapter not initialized"); 
      return; 
     } 
     BluetoothGattService mCustomService = mBluetoothGatt.getService(UUID.fromString("0000bc01-0000-1000-8000-00805f9b34fb")); 
     if(mCustomService == null){ 
      Log.w(TAG, "Custom BLE Service not found"); 
      return; 
     } 
     BluetoothGattCharacteristic mWriteCharacteristic = mCustomService.getCharacteristic(UUID.fromString("0000bd01-0000-1000-8000-00805f9b34fb")); 
     try { 
      byte [] message = new byte [6]; 
      message[0] = (byte) 0x1B; 
      message[1] = (byte) 0x00; 
      message[2] = (byte) 0x02; 
      message[3] = (byte) 0x25; 
      message[4] = (byte) 0x27; 
      message[5] = (byte) 0x1b; 
      mWriteCharacteristic.setValue(message); 
      if(mBluetoothGatt.writeCharacteristic(mWriteCharacteristic)==true){ 
       Log.w(TAG, "Write Char Success"); 
      } 
      else{ 
       Log.w(TAG, "Write Char Faile"); 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

`

+0

あなたのケースでは、1.BluetoothGattServiceがnullの場合、falseを返す可能性があります。plsチェックしてください。 2.BluetoothDeviceがnullの場合はfalseを返します; 3.リモートデバイスがビジーの場合はfalseを返します。 4.この問題を再現するのに十分なコードを示しているRemoteExceptionが発生しました – shuabing

+0

。 – GPS

+0

@GPS私はこのウォーキングサンプルに従っています。http://www.allaboutcircuits.com/projects/how-to-communicate-with-a-custom-ble-using-an-android-app/ – user2372490

答えて

0

あなたはあなたがリードコマンドを実行できるようになるまで、対応するコールバックを待つ必要がmBluetoothGatt.writeDescriptor(descriptor);呼び出した後。

+0

私はwriteDescriptorを実行した後ではありませんコールバックを取得しています。 – user2372490

関連する問題