Intro-To-RxJava | An extensive tutorial on RxJava | Reactive Programming library

You are on the right track. However, you want to create an observable so you probably want Observable.create and not Observer.create. It is very confusing because Observable.create needs a function which takes in an Observer. That function can then emit items into that Observer.

You are also keen to recognize that you want a hot observable. However, Observable.create is going to give you a hot observable anyways. You will still want to use some kind of publish to avoid multiple subscriptions. We will do that with share. As for the buffering, you can probably use buffer. At the end of the day I think it would be something like...

• A - An observable created with Observable.create wrapped around your socket callbacks.
• B - Wrap A with share
• C - flatMap B to go from a stream of buffers to a stream of items
• D - Watch C and use filter/where to only emit on 03.
• E - buffer C using D as your closing selector

Then expose E as the public API of your service. E will emit the entire message any time a message arrives.

*Note, this method assumes you get messages back-to-back and thus we don't bother with the 02 signal as we know the first byte after the end of a message must be the start of the next message. If this is not the case you will want to handle that better.

** You can share after the flatMap. This will be slightly more performant. You cannot share after the buffer.

*** On a re-read of your question I noticed you want a stream of streams and not a stream of arrays. To get this result you can take the output of buffer and run it through flatMap using Observable.of This will give you hot stream of cold streams.