MissingBackpressureException even .onBackpressureDrop() is added?

Hey. I’m using RxAndroidBle for connection / writing data etc stuffs. And with long stream operation like subscribe to resource ( 1-3min) I got MissingBackpressureException ( bottom of source code with Log.e). Any idea what is wrong here?

// Setup notifications for incoming data
                           RxBleConnection connection = connectionMap.get(bleMac);
                           Subscription notifySubscription = connection.setupNotification(notifyCharacteristic)
                                   .doOnNext(new Action1<Observable<byte[]>>() {
                                       @Override
                                       public void call(Observable<byte[]> observable) {
                                           Log.d(TAG, "Notifications set, calling bypassConnect()");

                                           // Bypass connect in WB to make it aware of this new device
                                           String wbAddress = addressMap.getOrCreateWbAddress(bleMac);
                                           bleWrapper.bypassConnect(wbAddress);
                                       }
                                   })
                                   .flatMap(new Func1<Observable<byte[]>, Observable<byte[]>>() {
                                       @Override
                                       public Observable<byte[]> call(Observable<byte[]> observable) {
                                           return observable;
                                       }
                                   })
                                   .onBackpressureDrop()
                                   .subscribe(new Action1<byte[]>() {
                                       @Override
                                       public void call(byte[] bytes) {
                                           dataAvailable(bleMac, bytes);
                                       }
                                   }, new Action1<Throwable>() {
                                       @Override
                                       public void call(Throwable throwable) {
                                           Log.e(TAG, "dataAvailable() Error: " + throwable);
                                       }
                                   });

[dariuszseweryn]

Finally I had time to dig into this issue. I have prepared a peripheral that sends out ~400 notifications per second and it worked as long as the consumer was quick:

device.establishConnection(false)
        .flatMap(connection -> connection.setupNotification(uuid))
        .flatMap(observable -> observable)
        .subscribe(
                bytes -> Log.i("Received", "."),
                throwable -> Log.e("Error", "Whoops!", throwable)
        );

Then I have made the consumer slower by adding a Thread.sleep(10) and I quickly got MissingBackpressureException. I have then started to play with .onBackpressureDrop() and adding it right before .subscribe() did not fixed the issue. I have checked the Javadoc of .onBackpressureDrop() and it says:

     * If the downstream request count hits 0 then the Observable will refrain from calling {@code onNext} until
     * the observer invokes {@code request(n)} again to increase the request count.

Then I have checked the Javadoc of .subscribe():

     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
     *  backpressure is applied to it).</dd>

This means that applying .onBackpressureDrop() just before .subscribe() does nothing as the .subscribe() is not applying backpressure to the upstream. .onBackpressure*() should be applied before an operator that applies backpressure to the upstream i.e. .observeOn(Scheduler) which Javadoc says:

     *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
     *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
     *  pops up; look for sources up the chain that don't support backpressure,
     *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
     *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>

i.e. this will work:

device.establishConnection(false)
        .flatMap(connection -> connection.setupNotification(uuid))
        .flatMap(observable -> observable)
        .onBackpressureDrop()
        .observeOn(Schedulers.computation())
        .subscribe(
                bytes -> {
                    Log.i("Received", ".");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                },
                throwable -> Log.e("Error", "Whoops!", throwable)
        );

but this will not:

device.establishConnection(false)
        .flatMap(connection -> connection.setupNotification(uuid))
        .flatMap(observable -> observable)
        .observeOn(Schedulers.computation())
        .onBackpressureDrop()
        .subscribe(
                bytes -> {
                    Log.i("Received", ".");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                },
                throwable -> Log.e("Error", "Whoops!", throwable)
        );

Summary: the behaviour of the library is correct. The aim of RxAndroidBle is to provide all BLE events to the user. Applying backpressure mechanisms inside the library would make it harder for the user to understand why they would not get all the notifications the device has sent if they consume them too slow.

[dariuszseweryn]

@TeemuStenhammar Sorry for such a delay (I was on holiday)—could you add on what phone did the problem surfaced? How quick and of what size the notifications are?