Java Code Examples for android.bluetooth.bluetoothgatt#GATT_INVALID_ATTRIBUTE_LENGTH

The following examples show how to use android.bluetooth.bluetoothgatt#GATT_INVALID_ATTRIBUTE_LENGTH . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example 1

Source File: HeartRateServiceFragment.java From ble-test-peripheral-android with Apache License 2.0

6 votes

@Override
public int writeCharacteristic(BluetoothGattCharacteristic characteristic, int offset, byte[] value) {
  if (offset != 0) {
    return BluetoothGatt.GATT_INVALID_OFFSET;
  }
  // Heart Rate control point is a 8bit characteristic
  if (value.length != 1) {
    return BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH;
  }
  if ((value[0] & 1) == 1) {
    getActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        mHeartRateMeasurementCharacteristic.setValue(INITIAL_EXPENDED_ENERGY,
            EXPENDED_ENERGY_FORMAT, /* offset */ 2);
        mEditTextEnergyExpended.setText(Integer.toString(INITIAL_EXPENDED_ENERGY));
      }
    });
  }
  return BluetoothGatt.GATT_SUCCESS;
}

Example 2

Source File: BleUtils.java From bleYan with GNU General Public License v2.0

5 votes

public static String getGattStatus(int status) {
    switch (status) {
        case BluetoothGatt.GATT_SUCCESS:
            return "GATT_SUCCESS";

        case BluetoothGatt.GATT_READ_NOT_PERMITTED:
            return "GATT_READ_NOT_PERMITTED";

        case BluetoothGatt.GATT_WRITE_NOT_PERMITTED:
            return "GATT_WRITE_NOT_PERMITTED";

        case BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION:
            return "GATT_INSUFFICIENT_AUTHENTICATION";

        case BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED:
            return "GATT_REQUEST_NOT_SUPPORTED";

        case BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION:
            return "GATT_INSUFFICIENT_ENCRYPTION";

        case BluetoothGatt.GATT_INVALID_OFFSET:
            return "GATT_INVALID_OFFSET";

        case BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH:
            return "GATT_INVALID_ATTRIBUTE_LENGTH";

        case BluetoothGatt.GATT_FAILURE:
            return "GATT_FAILURE";

        default:
            return "STATE_UNKNOWN: " + status;
    }
}

Example 3

Source File: HealthThermometerServiceFragment.java From ble-test-peripheral-android with Apache License 2.0

5 votes

@Override
public int writeCharacteristic(BluetoothGattCharacteristic characteristic, int offset, byte[] value) {
  if (offset != 0) {
    return BluetoothGatt.GATT_INVALID_OFFSET;
  }
  // Measurement Interval is a 16bit characteristic
  if (value.length != 2) {
    return BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH;
  }
  ByteBuffer byteBuffer = ByteBuffer.wrap(value);
  byteBuffer.order(ByteOrder.LITTLE_ENDIAN);
  final int newMeasurementIntervalValue = byteBuffer.getShort();
  if (!isValidMeasurementIntervalValue(newMeasurementIntervalValue)) {
    return BluetoothGatt.GATT_FAILURE;
  }
  getActivity().runOnUiThread(new Runnable() {
    @Override
    public void run() {
      mMeasurementIntervalCharacteristic.setValue(newMeasurementIntervalValue,
          MEASUREMENT_INTERVAL_FORMAT,
          /* offset */ 0);
      if (mMeasurementIntervalCCCDescriptor.getValue() == BluetoothGattDescriptor.ENABLE_INDICATION_VALUE) {
        resetTimer(newMeasurementIntervalValue);
        mTextViewNotifications.setText(R.string.notificationsEnabled);
      }
    }
  });
  return BluetoothGatt.GATT_SUCCESS;
}

Example 4

Source File: EddystoneGattService.java From beacons-android with Apache License 2.0

4 votes

public int writeCharacteristic(BluetoothDevice device, BluetoothGattCharacteristic characteristic, byte[] value) {
//        UUID uuid = characteristic.getUuid();
        if (isLocked()) {
            if (characteristic == mUnlockCharacteristic) {
                if (value.length == 16) {
                    byte[] token = aes_transform(true, characteristic.getValue(), 0, 16);
                    if (Arrays.equals(token, value)) {
                        log(String.format("Unlocked by %s", device));

                        mOwnerDevice = device;
                        mGattServer.disconnectAll(device);
                        characteristic.setValue((byte[]) null);
                        mLockStateCharacteristic.setValue(new byte[] { LOCK_STATE_UNLOCKED});

                        return BluetoothGatt.GATT_SUCCESS;
                    }
                    else log("Unlock failed!");
                }
                else log(String.format(Locale.US, "Unlock: expected 16 bytes, got %d", value.length));
            }

            log("Beacon locked - write request denied");
            return BluetoothGatt.GATT_WRITE_NOT_PERMITTED;
        }

        if (characteristic == mLockStateCharacteristic) {
            if (LOCK_STATE_LOCKED == value[0] && 17 == value.length) {
                mLockKey = aes_transform(false, value, 1, 16);
                mConfigCallback.setLockKey(mLockKey);
                log("Lock key changed");
            }
            characteristic.setValue(new byte[]{value[0]});
        } else if (characteristic == mActiveSlotCharacteristic) {
            log("Request to change active slot to " + value[0]);
            if (value[0] != 1) {
                // Beacon Tools tries to change the active slot to 1
                return BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH;
            }
        } else if (characteristic == mRadioTxPowerCharacteristic) {
            if (value.length == 1) {
                int txPower = mConfigCallback.setRadioTxPower(value[0]);
                characteristic.setValue(txPower, BluetoothGattCharacteristic.FORMAT_SINT8, 0);

                // if Radio TX has changed, then Advertised TX has also changed
                mAdvertisedTxPowerCharacteristic.setValue(mConfigCallback.getAdvertisedTxPower(), BluetoothGattCharacteristic.FORMAT_SINT8, 0);
                log(String.format(Locale.US, "Radio TX Power %d was requested. Actual value is now %d",
                        value[0], txPower));
            }
            else {
                log("Invalid Radio TX power value size: " + value.length);
            }
        } else if (characteristic == mAdvertiseIntervalCharacteristic) {
            if (value.length == 2) {
                int wantedAdvertiseInterval = unpackShort(value);
                int actualAdvertiseInterval = mConfigCallback.setAdvertiseInterval(wantedAdvertiseInterval);
                characteristic.setValue(toBigEndian(actualAdvertiseInterval), BluetoothGattCharacteristic.FORMAT_UINT16, 0);
                log(String.format(Locale.US, "Advertise Interval %d was requested. Actual value is now %d",
                        wantedAdvertiseInterval, actualAdvertiseInterval));
            }
            else {
                log("Invalid Advertise Interval value size: " + value.length);
            }
        } else if (characteristic == mAdvSlotDataCharacteristic) {
            handleWriteAdvertiseSlotData(value);
        } else if (characteristic == mFactoryResetCharacteristic) {
            if (0x0B == value[0]) {
                factoryReset();
            }
        }

        return BluetoothGatt.GATT_SUCCESS;
    }

Example 5

Source File: Peripheral.java From ble-test-peripheral-android with Apache License 2.0

4 votes

@Override
public void onDescriptorWriteRequest(BluetoothDevice device, int requestId,
    BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded,
    int offset,
    byte[] value) {
  super.onDescriptorWriteRequest(device, requestId, descriptor, preparedWrite, responseNeeded,
      offset, value);
  Log.v(TAG, "Descriptor Write Request " + descriptor.getUuid() + " " + Arrays.toString(value));
  int status = BluetoothGatt.GATT_SUCCESS;
  if (descriptor.getUuid() == CLIENT_CHARACTERISTIC_CONFIGURATION_UUID) {
    BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();
    boolean supportsNotifications = (characteristic.getProperties() &
        BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0;
    boolean supportsIndications = (characteristic.getProperties() &
        BluetoothGattCharacteristic.PROPERTY_INDICATE) != 0;

    if (!(supportsNotifications || supportsIndications)) {
      status = BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED;
    } else if (value.length != 2) {
      status = BluetoothGatt.GATT_INVALID_ATTRIBUTE_LENGTH;
    } else if (Arrays.equals(value, BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE)) {
      status = BluetoothGatt.GATT_SUCCESS;
      mCurrentServiceFragment.notificationsDisabled(characteristic);
      descriptor.setValue(value);
    } else if (supportsNotifications &&
        Arrays.equals(value, BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE)) {
      status = BluetoothGatt.GATT_SUCCESS;
      mCurrentServiceFragment.notificationsEnabled(characteristic, false /* indicate */);
      descriptor.setValue(value);
    } else if (supportsIndications &&
        Arrays.equals(value, BluetoothGattDescriptor.ENABLE_INDICATION_VALUE)) {
      status = BluetoothGatt.GATT_SUCCESS;
      mCurrentServiceFragment.notificationsEnabled(characteristic, true /* indicate */);
      descriptor.setValue(value);
    } else {
      status = BluetoothGatt.GATT_REQUEST_NOT_SUPPORTED;
    }
  } else {
    status = BluetoothGatt.GATT_SUCCESS;
    descriptor.setValue(value);
  }
  if (responseNeeded) {
    mGattServer.sendResponse(device, requestId, status,
        /* No need to respond with offset */ 0,
        /* No need to respond with a value */ null);
  }
}