android.bluetooth.BluetoothGattService Java Examples

@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
        boolean connected = false;

        BluetoothGattService service = gatt.getService(SERVICE_UUID);
        if (service != null) {
            BluetoothGattCharacteristic characteristic = service.getCharacteristic(CHARACTERISTIC_COUNTER_UUID);
            if (characteristic != null) {
                gatt.setCharacteristicNotification(characteristic, true);

                BluetoothGattDescriptor descriptor = characteristic.getDescriptor(DESCRIPTOR_CONFIG);
                if (descriptor != null) {
                    descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                    connected = gatt.writeDescriptor(descriptor);
                }
            }
        }
        mListener.onConnected(connected);
    } else {
        Log.w(TAG, "onServicesDiscovered received: " + status);
    }
}
 

@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    if (status != GATT_SUCCESS) {
        Timber.e("service discovery failed due to internal error '%s', disconnecting", statusToString(status));
        disconnect();
        return;
    }

    final List<BluetoothGattService> services = gatt.getServices();
    Timber.i("discovered %d services for '%s'", services.size(), getName());

    if (listener != null) {
        listener.connected(BluetoothPeripheral.this);
    }

    callbackHandler.post(new Runnable() {
        @Override
        public void run() {
            peripheralCallback.onServicesDiscovered(BluetoothPeripheral.this);
        }
    });
}
 

public void read(UUID serviceUUID, UUID characteristicUUID, Callback callback) {

		if (!isConnected()) {
			callback.invoke("Device is not connected", null);
			return;
		}
		if (gatt == null) {
			callback.invoke("BluetoothGatt is null", null);
			return;
		}

		BluetoothGattService service = gatt.getService(serviceUUID);
		BluetoothGattCharacteristic characteristic = findReadableCharacteristic(service, characteristicUUID);

		if (characteristic == null) {
			callback.invoke("Characteristic " + characteristicUUID + " not found.", null);
		} else {
			readCallback = callback;
			if (!gatt.readCharacteristic(characteristic)) {
				readCallback = null;
				callback.invoke("Read failed", null);
			}
		}
	}
 

public boolean writeDescriptor(String	address,
  							   UUID		serviceUUID,
  							   UUID		characteristicUUID,
  							   UUID		descriptorUUID,
						   byte[]	value) throws DeviceManagerException, DeviceNameNotFoundException {
BTDeviceInfo deviceInfo = getDeviceInfo(address);
if (deviceInfo == null) {
	throw new DeviceNameNotFoundException(String.format("%s %s", mContext.getString(R.string.device_not_found), address));   		    		
}
BluetoothGattService service = deviceInfo.getGatt().getService(serviceUUID);
if (service == null) {
	throw new DeviceManagerException(String.format("%s %s %s", mContext.getString(R.string.service_not_found), address, serviceUUID));
}
BluetoothGattCharacteristic characteristic = service.getCharacteristic(characteristicUUID);
if (characteristic == null) {
	throw new DeviceManagerException(String.format("%s %s %s", mContext.getString(R.string.characteristic_not_found), address, characteristicUUID));
}
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(descriptorUUID);
if (descriptor == null) {
	throw new DeviceManagerException(String.format("%s %s %s %s", mContext.getString(R.string.descriptor_not_found), address, characteristicUUID, descriptorUUID));
}
return writeDescriptor(deviceInfo, characteristic, descriptor, value);
  }
 

/**
 * Setup BLOCK and IDENTIFY characteristics
 */
private void setupOAD() {
    BluetoothGattService oadService = mGattClient.getService(Constants.UUID_OAD_SERVICE);
    if (oadService == null) {
        fail(BeanError.MISSING_OAD_SERVICE);
        return;
    }

    oadIdentify = oadService.getCharacteristic(Constants.UUID_OAD_CHAR_IDENTIFY);
    if (oadIdentify == null) {
        fail(BeanError.MISSING_OAD_IDENTIFY);
        return;
    }

    oadBlock = oadService.getCharacteristic(Constants.UUID_OAD_CHAR_BLOCK);
    if (oadBlock == null) {
        fail(BeanError.MISSING_OAD_BLOCK);
        return;
    }
}
 

boolean connectedDeviceHostsService(UUID serviceUuid) {
    if (mockMode) {
        for (BluetoothGattService service : mockServices) {
            if (service.getUuid() != null && service.getUuid().equals(serviceUuid)) {
                return true;
            }
        }
        return false;
    } else {
        // if the device has not had discovery performed, we will not know that the connection
        // is hosting the service
        if (isConnected()) {
            return null != getGatt() && null != getGatt().getService(serviceUuid);
        } else {
            return false;
        }
    }
}
 

@NonNull
@Override
protected List<BluetoothGattService> initializeServer() {
	final List<BluetoothGattService> services = new ArrayList<>();
	services.add(
			service(ProximityManager.IMMEDIATE_ALERT_SERVICE_UUID,
					characteristic(ProximityManager.ALERT_LEVEL_CHARACTERISTIC_UUID,
							BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE,
							BluetoothGattCharacteristic.PERMISSION_WRITE))
	);
	services.add(
			service(ProximityManager.LINK_LOSS_SERVICE_UUID,
					characteristic(ProximityManager.ALERT_LEVEL_CHARACTERISTIC_UUID,
							BluetoothGattCharacteristic.PROPERTY_WRITE | BluetoothGattCharacteristic.PROPERTY_READ,
							BluetoothGattCharacteristic.PERMISSION_WRITE | BluetoothGattCharacteristic.PERMISSION_READ,
							AlertLevelData.highAlert()))
	);
	return services;
}
 

@Override
public boolean isRequiredServiceSupported(@NonNull final BluetoothGatt gatt) {
    final BluetoothGattService meshProxyService = gatt.getService(MESH_PROXY_UUID);
    if (meshProxyService != null) {
        isProvisioningComplete = true;
        mMeshProxyDataInCharacteristic = meshProxyService.getCharacteristic(MESH_PROXY_DATA_IN);
        mMeshProxyDataOutCharacteristic = meshProxyService.getCharacteristic(MESH_PROXY_DATA_OUT);

        return mMeshProxyDataInCharacteristic != null &&
               mMeshProxyDataOutCharacteristic != null &&
               hasNotifyProperty(mMeshProxyDataOutCharacteristic) &&
               hasWriteNoResponseProperty(mMeshProxyDataInCharacteristic);
    }
    final BluetoothGattService meshProvisioningService = gatt.getService(MESH_PROVISIONING_UUID);
    if (meshProvisioningService != null) {
        isProvisioningComplete = false;
        mMeshProvisioningDataInCharacteristic = meshProvisioningService.getCharacteristic(MESH_PROVISIONING_DATA_IN);
        mMeshProvisioningDataOutCharacteristic = meshProvisioningService.getCharacteristic(MESH_PROVISIONING_DATA_OUT);

        return mMeshProvisioningDataInCharacteristic != null &&
               mMeshProvisioningDataOutCharacteristic != null &&
               hasNotifyProperty(mMeshProvisioningDataOutCharacteristic) &&
               hasWriteNoResponseProperty(mMeshProvisioningDataInCharacteristic);
    }
    return false;
}
 

/**
 * Returns a {@link BleServer} instance. This is now the preferred method to retrieve the server instance.
 */
public final BleServer getServer(final IncomingListener incomingListener, final GattDatabase gattDatabase, final BleServer.ServiceAddListener addServiceListener)
{
	if (m_server == null)
	{
		m_server = new BleServer(this, /*isNull*/false);
		if (gattDatabase != null)
		{
			for (BluetoothGattService service : gattDatabase.getServiceList())
			{
				m_server.addService(service, addServiceListener);
			}
		}
	}
	m_server.setListener_Incoming(incomingListener);
	return m_server;
}
 

public BleDescriptorWrapper getDescriptor(final UUID serviceUuid_nullable, final UUID charUuid_nullable, final UUID descUuid)
{
    if (serviceUuid_nullable == null)
    {
        final List<BluetoothGattService> serviceList = getNativeServiceList_original();

        for (int i = 0; i < serviceList.size(); i++)
        {
            final BleServiceWrapper service_ith = new BleServiceWrapper(serviceList.get(i));
            final BleDescriptorWrapper descriptor = getDescriptor(service_ith, charUuid_nullable, descUuid);

            return descriptor;
        }
    }
    else
    {
        final BleServiceWrapper service = getServiceDirectlyFromNativeNode(serviceUuid_nullable);

        if (service.hasUhOh())
            return new BleDescriptorWrapper(service.getUhOh());
        else
            return getDescriptor(service, charUuid_nullable, descUuid);
    }

    return BleDescriptorWrapper.NULL;
}
 

public void uiCharacteristicsDetails(final BluetoothGatt gatt,
		 					 final BluetoothDevice device,
							 final BluetoothGattService service,
							 final BluetoothGattCharacteristic characteristic)
 {
 	runOnUiThread(new Runnable() {
@Override
public void run() {
	mListType = ListType.GATT_CHARACTERISTIC_DETAILS;
	mListView.setAdapter(mCharDetailsAdapter);
   	mHeaderTitle.setText(BleNamesResolver.resolveCharacteristicName(characteristic.getUuid().toString().toLowerCase(Locale.getDefault())) + "\'s details:");
   	mHeaderBackButton.setVisibility(View.VISIBLE);
   	
   	mCharDetailsAdapter.setCharacteristic(characteristic);
   	mCharDetailsAdapter.notifyDataSetChanged();
}
 	});
 }
 

/**
     * Reads the value for a given descriptor from the associated remote device.
     *
     * @param serviceUUID        remote device service uuid
     * @param characteristicUUID remote device characteristic uuid
     * @param descriptorUUID     remote device descriptor uuid
     * @return true, if the read operation was initiated successfully
     */
    public boolean readDescriptor(String serviceUUID, String characteristicUUID,
                                  String descriptorUUID) {
        if (mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothGatt is null");
            return false;
        }
//        try {
        BluetoothGattService service =
                mBluetoothGatt.getService(UUID.fromString(serviceUUID));
        BluetoothGattCharacteristic characteristic =
                service.getCharacteristic(UUID.fromString(characteristicUUID));
        BluetoothGattDescriptor descriptor =
                characteristic.getDescriptor(UUID.fromString(descriptorUUID));
        return mBluetoothGatt.readDescriptor(descriptor);
//        } catch (Exception e) {
//            Log.e(TAG, "read descriptor exception", e);
//            return false;
//        }
    }
 

/**
 * When the device is bonded and has the Generic Attribute service and the Service Changed characteristic this method enables indications on this characteristic.
 * In case one of the requirements is not fulfilled this method returns <code>false</code>.
 *
 * @return <code>true</code> when the request has been sent, <code>false</code> when the device is not bonded, does not have the Generic Attribute service, the GA service does not have
 * the Service Changed characteristic or this characteristic does not have the CCCD.
 */
private boolean ensureServiceChangedEnabled() {
	final BluetoothGatt gatt = bluetoothGatt;
	if (gatt == null)
		return false;

	// The Service Changed indications have sense only on bonded devices
	final BluetoothDevice device = gatt.getDevice();
	if (device.getBondState() != BluetoothDevice.BOND_BONDED)
		return false;

	final BluetoothGattService gaService = gatt.getService(GENERIC_ATTRIBUTE_SERVICE);
	if (gaService == null)
		return false;

	final BluetoothGattCharacteristic scCharacteristic = gaService.getCharacteristic(SERVICE_CHANGED_CHARACTERISTIC);
	if (scCharacteristic == null)
		return false;

	return internalEnableIndications(scCharacteristic);
}
 

/**
 * Return a configured {@link BluetoothGattService} instance for the
 * Current Time Service.
 */
public static BluetoothGattService createTimeService() {
    BluetoothGattService service = new BluetoothGattService(TIME_SERVICE,
            BluetoothGattService.SERVICE_TYPE_PRIMARY);

    // Current Time characteristic
    BluetoothGattCharacteristic currentTime = new BluetoothGattCharacteristic(CURRENT_TIME,
            //Read-only characteristic, supports notifications
            BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic.PROPERTY_NOTIFY,
            BluetoothGattCharacteristic.PERMISSION_READ);
    BluetoothGattDescriptor configDescriptor = new BluetoothGattDescriptor(CLIENT_CONFIG,
            //Read/write descriptor
            BluetoothGattDescriptor.PERMISSION_READ | BluetoothGattDescriptor.PERMISSION_WRITE);
    currentTime.addDescriptor(configDescriptor);

    // Local Time Information characteristic
    BluetoothGattCharacteristic localTime = new BluetoothGattCharacteristic(LOCAL_TIME_INFO,
            //Read-only characteristic
            BluetoothGattCharacteristic.PROPERTY_READ,
            BluetoothGattCharacteristic.PERMISSION_READ);

    service.addCharacteristic(currentTime);
    service.addCharacteristic(localTime);

    return service;
}
 

/**
   * 获取BLE的特征值
   * @param gattServices
   */
  private void getCharacteristic(List<BluetoothGattService> gattServices) {
      if (gattServices == null) return;
      String uuid = null;

      // Loops through available GATT Services.
      for (BluetoothGattService gattService : gattServices) {
          uuid = gattService.getUuid().toString();
          
          //找uuid为0000ffe0-0000-1000-8000-00805f9b34fb的服务
          if (uuid.equals(C.SERVICE_UUID)) {
          	List<BluetoothGattCharacteristic> gattCharacteristics =
                      gattService.getCharacteristics();
              //找uuid为0000ffe1-0000-1000-8000-00805f9b34fb的特征值
              for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                  uuid = gattCharacteristic.getUuid().toString();
                  if(uuid.equals(C.CHAR_UUID)){
                  	mCharacteristic = gattCharacteristic;
                  	final int charaProp = gattCharacteristic.getProperties();
              		//开启该特征值的数据的监听
              		if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                          mBluetoothLeService.setCharacteristicNotification(
                                  mCharacteristic, true);
                      }
                  	System.out.println("uuid----->" + uuid);
                  }
              }
	}
      }
      
      //如果没找到指定的特征值,直接返回
      if (mCharacteristic == null) {
      	Toast.makeText(DeviceControlActivity.this, "未找到指定特征值", 
      			Toast.LENGTH_LONG).show();
	finish();
}

  }
 

public void writeService(BluetoothGattService service, String uuid, byte[] value) {
    if (service != null) {
        if (mAdapter == null || mGatt == null) {
            Log.w(TAG, "writeService: BluetoothAdapter not initialized");
            return;
        }

        mExecutor.write(service, uuid, value);
        mExecutor.execute(mGatt);
    }
}
 

private void showData() {
    BleDevice bleDevice = ((OperationActivity) getActivity()).getBleDevice();
    String name = bleDevice.getName();
    String mac = bleDevice.getMac();
    BluetoothGatt gatt = BleManager.getInstance().getBluetoothGatt(bleDevice);

    txt_name.setText(String.valueOf(getActivity().getString(R.string.name) + name));
    txt_mac.setText(String.valueOf(getActivity().getString(R.string.mac) + mac));

    mResultAdapter.clear();
    for (BluetoothGattService service : gatt.getServices()) {
        mResultAdapter.addResult(service);
    }
    mResultAdapter.notifyDataSetChanged();
}
 

private static List<BluetoothGattCharacteristic> findCharacteristics(BluetoothGatt gatt, UUID serviceUuid, UUID characteristicUuid, int property) {
    if (serviceUuid == null) {
        return null;
    }

    if (characteristicUuid == null) {
        return null;
    }

    if (gatt == null) {
        return null;
    }

    BluetoothGattService service = gatt.getService(serviceUuid);
    if (service == null) {
        return null;
    }

    List<BluetoothGattCharacteristic> results = new ArrayList<>();
    for (BluetoothGattCharacteristic c : service.getCharacteristics()) {
        int props = c.getProperties();
        if (characteristicUuid.equals(c.getUuid())
                && (property == (property & props))) {
            results.add(c);
        }
    }
    return results;
}
 

private BluetoothGattCharacteristic getCharacteristic(BluetoothGatt bluetoothGatt, String uuid) {
    final UUID serviceUuid = UUID.fromString(getServiceUUID());
    final UUID characteristicUuid = UUID.fromString(uuid);

    final BluetoothGattService service = bluetoothGatt.getService(serviceUuid);
    return service.getCharacteristic(characteristicUuid);
}
 

@Override
public void onServiceAdded(int status, BluetoothGattService service) {
    super.onServiceAdded(status, service);

    Log.d(TAG, "GattServer: onServiceAdded");
    mAddServicesSemaphore.release();
}
 

@Test
public void writeDescriptor() {
    BluetoothGattCallback callback = connectAndGetCallback();
    callback.onConnectionStateChange(gatt, GATT_SUCCESS, STATE_CONNECTED);

    BluetoothGattService service = new BluetoothGattService(SERVICE_UUID, 0);
    BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(UUID.fromString("00002A1C-0000-1000-8000-00805f9b34fb"),PROPERTY_INDICATE,0);
    BluetoothGattDescriptor descriptor = new BluetoothGattDescriptor(UUID.fromString("00002903-0000-1000-8000-00805f9b34fb"),0);
    service.addCharacteristic(characteristic);
    characteristic.addDescriptor(descriptor);

    when(gatt.getServices()).thenReturn(Arrays.asList(service));
    byte[] originalByteArray = new byte[]{0x01};
    peripheral.writeDescriptor(descriptor, originalByteArray);

    verify(gatt).writeDescriptor(descriptor);

    callback.onDescriptorWrite(gatt, descriptor, 0);

    ArgumentCaptor<BluetoothPeripheral> captorPeripheral = ArgumentCaptor.forClass(BluetoothPeripheral.class);
    ArgumentCaptor<byte[]> captorValue = ArgumentCaptor.forClass(byte[].class);
    ArgumentCaptor<BluetoothGattDescriptor> captorDescriptor = ArgumentCaptor.forClass(BluetoothGattDescriptor.class);
    ArgumentCaptor<Integer> captorStatus = ArgumentCaptor.forClass(Integer.class);
    verify(peripheralCallback).onDescriptorWrite(captorPeripheral.capture(), captorValue.capture(), captorDescriptor.capture(), captorStatus.capture());

    byte[] value = captorValue.getValue();
    assertEquals(0x01, value[0]);
    assertNotEquals(value, originalByteArray);   // Check if the byte array has been copied
    assertEquals(peripheral, captorPeripheral.getValue());
    assertEquals(descriptor, captorDescriptor.getValue());
    assertEquals(GATT_SUCCESS, (int) captorStatus.getValue() );
}
 

@Test
public void connectNodeWithDebug(){

    BluetoothDevice device = spy(Shadow.newInstanceOf(BluetoothDevice.class));
    BluetoothDeviceShadow shadowDevice = Shadow.extract(device);

    BluetoothGattService debugService = new BluetoothGattService(BLENodeDefines.Services
            .Debug.DEBUG_SERVICE_UUID,BluetoothGattService.SERVICE_TYPE_PRIMARY);
    debugService.addCharacteristic(
            new BluetoothGattCharacteristic(BLENodeDefines.Services.Debug.DEBUG_STDERR_UUID,
                    BluetoothGattCharacteristic.PERMISSION_READ |
                            BluetoothGattCharacteristic.PERMISSION_WRITE,
                    BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic
                            .PROPERTY_NOTIFY));
    debugService.addCharacteristic(
            new BluetoothGattCharacteristic(BLENodeDefines.Services.Debug.DEBUG_TERM_UUID,
                    BluetoothGattCharacteristic.PERMISSION_READ |
                            BluetoothGattCharacteristic.PERMISSION_WRITE,
                    BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic
                            .PROPERTY_NOTIFY)
    );

    shadowDevice.addService(debugService);

    Node node = createNode(device);
    Assert.assertEquals(Node.State.Idle, node.getState());
    node.connect(RuntimeEnvironment.application);

    TestUtil.execAllAsyncTask();

    verify(device).connectGatt(eq(RuntimeEnvironment.application), eq(false),
            any(BluetoothGattCallback.class));
    Assert.assertEquals(Node.State.Connected, node.getState());
    Assert.assertTrue(node.getDebug()!=null);
}
 

@Override
public void onProfileReady() {
    List<BluetoothGattService> services = mGattClient.getServices();
    for (BluetoothGattService service : services) {
        if (service.getUuid().equals(Constants.UUID_BATTERY_SERVICE)) {
            mBatteryService = service;
        }
    }
    ready = true;
}
 

/**
 * write repeatedly to (4) to register for the events your app wants to see from the micro:bit.
 * e.g. write <1,1> to register for a 'DOWN' event on ButtonA.
 * Any events matching this will then start to be delivered via the MicroBit Event characteristic.
 *
 * @param eventService Bluetooth GATT service.
 * @param enable       Enable or disable.
 */
private void register_AppRequirement(BluetoothGattService eventService, boolean enable) {
    if(!enable) {
        return;
    }

    BluetoothGattCharacteristic app_requirements = eventService.getCharacteristic(CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS);
    if(app_requirements != null) {
        logi("register_AppRequirement() :: found Constants.ES_CLIENT_REQUIREMENTS ");
        /*
        Registering for everything at the moment
        <1,0> which means give me all the events from ButtonA.
        <2,0> which means give me all the events from ButtonB.
        <0,0> which means give me all the events from everything.
        writeCharacteristic(Constants.EVENT_SERVICE.toString(), Constants.ES_CLIENT_REQUIREMENTS.toString(), 0, BluetoothGattCharacteristic.FORMAT_UINT32);
        */
        writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS.toString(),
                EventCategories.SAMSUNG_REMOTE_CONTROL_ID, GattFormats.FORMAT_UINT32);
        writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS.toString(),
                EventCategories.SAMSUNG_CAMERA_ID, GattFormats.FORMAT_UINT32);
        writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS.toString(),
                EventCategories.SAMSUNG_ALERTS_ID, GattFormats.FORMAT_UINT32);
        writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS.toString(),
                EventCategories.SAMSUNG_SIGNAL_STRENGTH_ID, GattFormats.FORMAT_UINT32);
        writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs.ES_CLIENT_REQUIREMENTS.toString(),
                EventCategories.SAMSUNG_DEVICE_INFO_ID, GattFormats.FORMAT_UINT32);
        //writeCharacteristic(GattServiceUUIDs.EVENT_SERVICE.toString(), CharacteristicUUIDs
        //        .ES_CLIENT_REQUIREMENTS.toString(), EventCategories.SAMSUNG_TELEPHONY_ID,
        //        GattFormats.FORMAT_UINT32);
    }
}
 

public List<BluetoothGattService> getSupportedGattServices() {
    if(mBluetoothGatt == null) {
        Log.w(LOG_TAG, "getSupportedGattServices mBluetoothGatt not initialized");
        return null;
    }
    Log.d(LOG_TAG, "getSupportedGattServices");
    return mBluetoothGatt.getServices();
}
 

private static void appendServiceHeader(StringBuilder descriptionBuilder, BluetoothGattService bluetoothGattService) {
    descriptionBuilder
            .append("\n")
            .append(createServiceType(bluetoothGattService))
            .append(" - ")
            .append(createServiceName(bluetoothGattService))
            .append(" (")
            .append(LoggerUtil.getUuidToLog(bluetoothGattService.getUuid()))
            .append(")\n")
            .append("Instance ID: ").append(bluetoothGattService.getInstanceId())
            .append('\n');
}
 

private void onServicesDiscovered(RxBleDeviceServices services) {
    for (BluetoothGattService service : services.getBluetoothGattServices()) {
        if (d) UserError.Log.d(TAG, "Service: " + getUUIDName(service.getUuid()));
        if (service.getUuid().equals(BluetoothServices.CGMService)) {
            if (d) UserError.Log.i(TAG, "Found CGM Service!");
            if (!always_discover) {
                do_discovery = false;
            }
            changeState(STATE.CHECK_AUTH);
            return;
        }
    }
    UserError.Log.e(TAG, "Could not locate CGM service during discovery");
    incrementErrors();
}
 

@Override
public void onDiscoverServices(BluetoothGatt gatt) {
    //for test
    final BluetoothGattService gattService = gatt
.getService(UUID.fromString("E54EAA50-371B-476C-99A3-74d267e3edbe"));
    if (gattService != null) {
        final BluetoothGattCharacteristic connectConf =
                gattService.getCharacteristic(UUID.fromString("E54EAA55-371B-476C-99A3-74D267E3EDBE"));
        if(connectConf != null) {
            AppLog.i(TAG, "onDiscoverServices: connectConf()");
            connectConf.setValue(new byte[]{ (byte) 0x88 });
            write(connectConf);
        }
    }
}
 

public BleServicesAdapter(Context context, List<BluetoothGattService> gattServices,
        @Nullable DeviceDef def) {
    inflater = LayoutInflater.from(context);

    this.def = def;
    services = new ArrayList<>(gattServices.size());
    characteristics = new HashMap<>(gattServices.size());
    for (BluetoothGattService gattService : gattServices) {
        final List<BluetoothGattCharacteristic> gattCharacteristics = gattService
                .getCharacteristics();
        characteristics.put(gattService, new ArrayList<>(gattCharacteristics));
        services.add(gattService);
    }
}
 

private List<BluetoothGattDescriptor> collectAllNativeDescriptors(
        final UUID serviceUuid_nullable, final UUID charUuid_nullable, final Object forEach_nullable)
{
    final ArrayList<BluetoothGattDescriptor> toReturn = forEach_nullable == null ? new ArrayList<BluetoothGattDescriptor>() : null;
    final List<BluetoothGattService> serviceList_native = getNativeServiceList_original();

    for (int i = 0; i < serviceList_native.size(); i++)
    {
        final BleServiceWrapper service_ith = new BleServiceWrapper(serviceList_native.get(i));

        if (serviceUuid_nullable == null || !service_ith.isNull() && serviceUuid_nullable.equals(service_ith.getService().getUuid()))
        {
            final List<BluetoothGattCharacteristic> charList_native = getNativeCharacteristicList_original(service_ith);

            for (int j = 0; j < charList_native.size(); j++)
            {
                final BleCharacteristicWrapper char_jth = new BleCharacteristicWrapper(charList_native.get(j));

                if (charUuid_nullable == null || !char_jth.isNull() && charUuid_nullable.equals(char_jth.getCharacteristic().getUuid()))
                {
                    final List<BluetoothGattDescriptor> descriptors = getNativeDescriptorList_original(char_jth);

                    if (forEach_nullable != null)
                    {
                        if (Utils.doForEach_break(forEach_nullable, descriptors))
                        {
                            return P_Const.EMPTY_DESCRIPTOR_LIST;
                        }
                    }
                    else
                    {
                        toReturn.addAll(descriptors);
                    }
                }
            }
        }
    }

    return toReturn;
}