TransactionTooLargeException from rememberSaveable exceeding Bundle parcel limit

Direct Answer

• Q1: The Compose compiler should emit a lint warning for any rememberSaveable key whose type suggests a high risk of exceeding the parcel budget (e.g., collections, bitmaps, or large data classes). A compile‑time check is the most reliable guard because the exact size is only known after serialization and the platform limit is opaque to app code.
• Q2: A lightweight runtime API that reports the current Bundle size is technically feasible, but it would add overhead to every state change and still cannot guarantee compliance with every OEM’s IPC buffer limit. It is more practical to rely on compile‑time lint and developer‑side size checks.
• Q3: Automatically splitting a single large rememberSaveable entry into multiple Bundle keys would break the atomic restoration guarantee. After a process kill, the entries could be restored in an inconsistent order, leading to a corrupted state tree.

Why Lint Is the Right Tool

The rememberSaveable value is marshalled into a Bundle that is later written to a Binder transaction. The Binder buffer is typically limited to roughly 50–100 KB, but the exact value varies by API level and OEM. Because the size is only determinable after the value has been marshalled, a compile‑time lint rule that flags potentially large types can catch many problems early. Runtime size checks would need to serialize the data on every state change, which is expensive and still cannot guarantee that the final IPC buffer will not be exceeded.

Practical Mitigation Steps

1. Limit the data you save. Prefer primitive types or small Parcelable objects. If you need to persist a large list, store it in a ViewModel or a database and only keep an identifier in rememberSaveable.
2. Use a custom Saver that trims or compresses data. For example, convert a bitmap to a compressed ByteArray and store the array size. Verify the size by marshalling the object into a Parcel and checking Parcel.dataSize() in a unit test.
3. Enable StrictMode for state operations. Add StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectLeakedClosableObjects().build()); in debug builds to catch large Bundle writes.
4. Test on physical devices across API levels. Log the size of savedInstanceState right before onSaveInstanceState:

   override fun onSaveInstanceState(outState: Bundle) {
       super.onSaveInstanceState(outState)
       val sizeBytes = Parcel.obtain().apply {
           writeBundle(outState)
           dataSize()
       }
       Log.d("SaveState", "sizeBytes=$sizeBytes")
   }
   

5. Avoid splitting. If you must store more than ~80 KB, consider persisting to a file or database and only keep a reference key in rememberSaveable.

Missing Diagnostic Detail

To refine the recommendation, could you share the approximate byte size of the data you are currently saving with rememberSaveable and the target API level/OEM you are deploying to?

Summary

Lint is the most efficient way to flag high‑risk rememberSaveable usages. A lightweight runtime size query can help in debugging, but it cannot replace compile‑time safety. Splitting entries is discouraged because it breaks restoration atomicity. By trimming data, using custom savers, and testing on real devices, you can keep state restoration within the Binder IPC budget and avoid TransactionTooLargeException.