decodeToSequence won't start parsing until 16k bytes of data arrives

[kustra]

Describe the bug
I'm attempting to parse an InputStream from an Android BluetoothSocket. The Bluetooth device on the other end sends a whitespace-separated stream of JSON entries. The end-of-stream only happens once the app disconnects from the Bluetooth device. These entries are responses to requests sent by the app.

The issue is that until a certain amount of data arrives from the Bluetooth device, decodeToSequence won't produce even a single entry. The typical size of a JSON entry sent by the device is around 100 bytes. I would like to process it as soon as it arrives.

To Reproduce

@OptIn(ExperimentalSerializationApi::class)
@Test
fun decodeFromStreamPreloadBug() {
    @Serializable
    data class MyResponse(val contents: String)

    val source = PipedOutputStream()
    val producer = Executors.newSingleThreadExecutor()
    producer.submit {
        for (i in 0 until 500) {
            source.write(Json.encodeToString(MyResponse("lorem ipsum")).toByteArray(Charsets.UTF_8))
        }
    }

    val sink = PipedInputStream(source)
    val seq = Json.decodeToSequence<MyResponse>(sink, DecodeSequenceMode.WHITESPACE_SEPARATED)
    for (response in seq) {
        println(response)
    }
}

This code blocks indefinitely, on the val seq = ... line. If I change the number of messages sent by the producer from 500 to 700, it prints 625 responses, then blocks indefinitely.

Pretty sure the issue is in the initial call of ReaderJsonLexer::preload.

Expected behavior
Get the next entry from the Bluetooth device as soon as it arrives.

Environment

• Kotlin version: 1.7.20
• Library version: 1.4.1
• Kotlin platforms: JVM (Android)
• Gradle version: no idea. Whatever is used by the Android Gradle Plugin 7.3.0
• IDE version: Android Studio Dolphin 2021.3.1

[sandwwraith]

Thank you for the detailed reproducer! I think the problem is in this line:

kotlinx.serialization/formats/json/commonMain/src/kotlinx/serialization/json/internal/lexer/JsonLexer.kt

Line 83 in 0c0648e

while (filledCount != sizeTotal) {

Lexer always tries to fill the buffer completely with multiple calls to .read in a loop. This is a reasonable behavior when we're decoding a single object from the stream, but may cause problems when the same lexer reused for multiple objects that are smaller than a buffer size

[kustra]

Here's some additional context for this use case. It might help in figuring out the correct solution.

Bluetooth Low Energy communication is based on packets. All the data in a packet is made available to the app at once.
The maximum payload of a packet is:

• 245-251 bytes in Bluetooth 4.2, with Data Length Extension.
• 27 bytes in Bluetooth 4.0 and 4.1.

In case the JSON string doesn't fit into a single packet, it's sent in multiple packets. Also, in case the app doesn't read incoming data fast enough, it'll receive the contents of multiple incoming packets with a single read.

My particular device uses Data Length Extension, and all JSON structures sent by the device are smaller than 245 bytes, so I always receive at least one full JSON structure in a single InputStream::read call.