class MyBleManager extends BleManager {
	private static final String TAG = "MyBleManager";

	private BluetoothGattCharacteristic fluxCapacitorControlPoint;

	public MyBleManager(@NonNull final Context context) {
		super(context);
	}

	@Override
	public int getMinLogPriority() {
		// Use to return minimal desired logging priority.
		return Log.VERBOSE;
	}

	@Override
	public void log(int priority, @NonNull String message) {
		// Log from here.
		Log.println(priority, TAG, message);
	}

 	@NonNull
	@Override
	protected BleManagerGattCallback getGattCallback() {
		return new MyGattCallbackImpl();
	}

	private class MyGattCallbackImpl extends BleManagerGattCallback {
		@Override
		protected boolean isRequiredServiceSupported(@NonNull BluetoothGatt gatt) {
			// Here get instances of your characteristics.
			// Return false if a required service has not been discovered.
			BluetoothGattService fluxCapacitorService = gatt.getService(FLUX_SERVICE_UUID);
			if (fluxCapacitorService != null) {
				fluxCapacitorControlPoint = fluxCapacitorService.getCharacteristic(FLUX_CHAR_UUID);
			}
			return fluxCapacitorControlPoint != null;
		}

		@Override
		protected void initialize() {
			// Initialize your device.
			// This means e.g. enabling notifications, setting notification callbacks,
			// sometimes writing something to some Control Point.
			// Kotlin projects should not use suspend methods here, which require a scope.
			requestMtu(517)
				.enqueue();
		}

		@Override
		protected void onServicesInvalidated() {
			// This method is called when the services get invalidated, i.e. when the device
			// disconnects.
			// References to characteristics should be nullified here.
			fluxCapacitorControlPoint = null;
		}
	}

	// Here you may add some high level methods for your device:
	public void enableFluxCapacitor() {
		// Do the magic.
		writeCharacteristic(fluxCapacitorControlPoint, Flux.enable(), BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE)
			.enqueue()
	}
}

connect(bluetoothDevice)
	// Automatic retries are supported, in case of 133 error.
	.retry(3 /* times, with */, 100 /* ms interval */)
	// A connection timeout can be set. This is additional to the Android's connection timeout which is 30 seconds.
	.timeout(15_000 /* ms */)
	// The auto connect feature from connectGatt is available as well
	.useAutoConnect(true)
	// This API can be set on any Android version, but will only be used on devices running Android 8+ with
	// support to the selected PHY.
	.usePreferredPhy(PhyRequest.PHY_LE_1M_MASK | PhyRequest.PHY_LE_2M_MASK | PhyRequest.PHY_LE_CODED_MASK)
	// A connection timeout can be also set. This is additional to the Android's connection timeout which is 30 seconds.
	.timeout(15_000 /* ms */)
	// Each request has number of callbacks called in different situations:
	.before(device -> { /* called when the request is about to be executed */ })
	.done(device -> { /* called when the device has connected, has required services and has been initialized */ })
	.fail(device, status -> { /* called when the request has failed */ })
	.then(device -> { /* called when the request was finished with either success, or a failure */ })
	// Each request must be enqueued.
	// Kotlin projects can use suspend() or suspendForResult() instead.
	// Java projects can also use await() which is blocking.
	.enqueue()

writeCharacteristic(someCharacteristic, someData, BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE)
	// Outgoing data can use automatic splitting.
	.split(customSplitter, progressCallback  /* optional */)
	// .split() with no parameters uses the default MTU splitter.
	// Kotlin projects can use .splitWithProgressAsFlow(customSplitter) to get the progress as Flow.
	.before(device -> { /* called when the request is about to be executed */ })
	.with(device, data -> { /* called when the request has been executed */ })
	.done(device -> { /* called when the request has completed successfully */ })
	.fail(device, status -> { /* called when the request has failed */ })
	.invalid({ /* called when the request was invalid, i.e. the target device or given characteristic was null */ })
	.then(device -> { /* called when the request was finished with either success, or a failure */ })
	// Remember to enqueue each request.
	.enqueue()

readCharacteristic(someCharacteristic)
	// Incoming data can use automatic merging.
	.merge(customMerger, progressCallback /* optional */)
	// Kotlin projects can use .mergeWithProgressAsFlow(customMerger) to get the progress as Flow.
	// Incoming packets can also be filtered, so that not everything goes to the merger.
	.filter(dataFilter)
	// Complete, merged packets can also be filtered.
	.filterPacket(packetFilter)
	// [...]
	.with(device, data -> { /* called when the data have been received */ })
	// [...]
	// Once again, remember to enqueue each request!
	.enqueue()