fix: SSE streaming stall on MAUI Android (SDK-2755)

[tanderson-ld]

Summary

Fixes a 60–90 second streaming stall observed by a LaunchDarkly customer running the .NET client SDK on MAUI Android. Root cause is a buffer-size interaction between LaunchDarkly.EventSource's StreamReader (default 1024-byte buffer) and Xamarin.Android.Net's AndroidMessageHandler, which silently wraps HTTP response bodies in a System.IO.BufferedStream with a 4096-byte default. Payload sizes in the ~1 KiB – ~4 KiB range trigger a code path where BufferedStream over-drains the underlying Java InputStream, causing the subsequent read to block waiting for the next server-side SSE keepalive (~60 s later).

Also adds the missing contract-tests/ service so LaunchDarkly.EventSource can participate in the sse-contract-tests harness alongside the Go, JavaScript, Java, and C++ SSE libraries.

Commits

• chore: add SSE contract-tests service — Adds contract-tests/ (TestService.csproj, TestService.cs, StreamEntity.cs, Representations.cs, README.md). Mirrors the structure of okhttp-eventsource's Java contract-tests service. Uses LaunchDarkly.TestHelpers.HttpTest (idiomatic .NET version of Java's test-helpers). Not shipped in the NuGet package. Declares the payload-size-stress-testable capability so this repo participates in the new sweep from feat: add payload-size-stress-testable capability and test sweep sse-contract-tests#42.

• fix: increase SSE read buffer to 8192 bytes... — Bumps EventSourceService's StreamReader buffer and ByteArrayLineScanner buffer from their previous 1024 / 1000 to a shared 8192. 8192 matches Okio's Segment.SIZE and gives one doubling of headroom over BufferedStream's current 4096-byte default. Both text-mode and PreferDataAsUtf8Bytes paths are covered.

Root cause detail

Full mechanism: BufferedStream.Read (dotnet/runtime) with count < _bufferSize takes a code path that fills its internal 4096-byte buffer via a single _stream.Read(_buffer, 0, _bufferSize) call. On MAUI Android this call goes into AndroidMessageHandler's InputStreamInvoker, which is a thin passthrough to Java HttpURLConnection.getInputStream().read(...). When the whole first SSE HTTP chunk arrives in one TCP burst and fits inside 4096 bytes, BufferedStream drains it entirely on the first user Read. The next user Read triggers a second Java read(), which blocks on the socket. Since LaunchDarkly's SSE server only sends the next chunk (a : keepalive) at ~60-second intervals, that second read stalls the whole client for 60–90 seconds.

Setting the SSE reader's buffer to >= BufferedStream._bufferSize routes into BufferedStream's passthrough branch instead, so each user Read maps 1:1 to a single Java read with no over-drain. Empirically confirmed with a reproduction repo that swept payload sizes 510 B – 33 KiB across buffer configurations of 1 KiB, 4 KiB, 8 KiB, and 32 KiB, plus regression testing showing the 1 KiB reader stalls at 4/8 sub-4 KiB sizes and the 8 KiB reader passes all sizes.

Test plan

• Existing LaunchDarkly.EventSource.Tests all pass (131 tests, 0 failures)
• New contract-tests service builds cleanly (dotnet build)
• Contract-tests service handles a GET / status request
• Payload-size stress sweep (80 sizes, 1 B through 128 MiB, ±1 around every power of 2) passes against the fixed EventSource via sse-contract-tests harness
• Manual verification against AndroidMessageHandler on Android emulator (deferred — requires the automated Android CI runner, tracked separately)

Related

• Depends on: feat: add payload-size-stress-testable capability and test sweep sse-contract-tests#42 (adds the payload-size-stress-testable capability + sweep test suite that this PR opts into)
• Downstream: LaunchDarkly.ClientSdk will get the fix via a dependency version bump in dotnet-core (separate PR against SDK-2755)

---

Note

Medium Risk
Core streaming read path changes affect all platforms; mitigated by contract tests and payload-size sweep, but Android-specific behavior is the main regression surface.

Overview
Fixes MAUI Android SSE stalls (~60–90s) by raising EventSourceService read buffers from ~1 KiB to 8192 bytes on both the StreamReader and ByteArrayLineScanner paths, avoiding AndroidMessageHandler’s 4096-byte BufferedStream over-read behavior (SDK-2755).

Adds SSE contract-test infrastructure: a desktop contract-tests/ HTTP wrapper around LaunchDarkly.EventSource for the shared sse-contract-tests harness, plus an Android variant (contract-tests-android/, MainActivity, shared TestService logic) with Makefile targets and scripts/start-android-test-service.sh. CI gains desktop contract tests (with documented skips for known gaps) and an emulator job that runs the harness against the Android build to catch regressions desktop cannot.

^{Reviewed by Cursor Bugbot for commit 6f57f61. Bugbot is set up for automated code reviews on this repo. Configure here.}

[jsonbailey]

Mainly nits on comments. I didn't mark all of them but all the "this is analogous..." comments can likely be removed.

[cursor]

Cursor Bugbot has reviewed your changes using default effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit c238772. Configure here.}