WIP adding real saveable support

Depends on workflow-runtime having an android source set and some other refactors.

Author: zach-klippenstein

workflow-runtime-android/src/main/java/com/squareup/workflow1/android/BundleSaveableStateRegistry.kt

@@ -0,0 +1,110 @@
+package com.squareup.workflow1.android
+
+import android.os.Binder
+import android.os.Bundle
+import android.os.Parcelable
+import android.util.Size
+import android.util.SizeF
+import android.util.SparseArray
+import androidx.compose.runtime.neverEqualPolicy
+import androidx.compose.runtime.referentialEqualityPolicy
+import androidx.compose.runtime.saveable.SaveableStateRegistry
+import androidx.compose.runtime.snapshots.SnapshotMutableState
+import androidx.compose.runtime.structuralEqualityPolicy
+import com.squareup.workflow1.Snapshot
+import java.io.Serializable
+
+/**
+ * A [SaveableStateRegistry] that can save and restore anything that can be saved in a [Bundle].
+ *
+ * Similar to Compose Android's `DisposableSaveableStateRegistry`.
+ */
+internal class BundleSaveableStateRegistry private constructor(
+  saveableStateRegistry: SaveableStateRegistry
+) : SaveableStateRegistry by saveableStateRegistry {
+  constructor(restoredValues: Map<String, List<Any?>>?) : this(
+    SaveableStateRegistry(restoredValues, ::canBeSavedToBundle)
+  )
+
+  // TODO move the functions from SnapshotParcels.kt into runtime-android.
+  // constructor(snapshot: Snapshot) : this(snapshot.toParcelable<Bundle>().toMap())
+  //
+  // fun toSnapshot(): Snapshot = performSave().toBundle().toSnapshot()
+}
+
+/**
+ * Checks that [value] can be stored inside [Bundle].
+ */
+private fun canBeSavedToBundle(value: Any): Boolean {
+  // SnapshotMutableStateImpl is Parcelable, but we do extra checks
+  if (value is SnapshotMutableState<*>) {
+    if (value.policy === neverEqualPolicy<Any?>() ||
+      value.policy === structuralEqualityPolicy<Any?>() ||
+      value.policy === referentialEqualityPolicy<Any?>()
+    ) {
+      val stateValue = value.value
+      return if (stateValue == null) true else canBeSavedToBundle(stateValue)
+    } else {
+      return false
+    }
+  }
+  // lambdas in Kotlin implement Serializable, but will crash if you really try to save them.
+  // we check for both Function and Serializable (see kotlin.jvm.internal.Lambda) to support
+  // custom user defined classes implementing Function interface.
+  if (value is Function<*> && value is Serializable) {
+    return false
+  }
+  for (cl in AcceptableClasses) {
+    if (cl.isInstance(value)) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Contains Classes which can be stored inside [Bundle].
+ *
+ * Some of the classes are not added separately because:
+ *
+ * - These classes implement Serializable:
+ *     - Arrays (DoubleArray, BooleanArray, IntArray, LongArray, ByteArray, FloatArray, ShortArray,
+ *       CharArray, Array<Parcelable>, Array<String>)
+ *     - ArrayList
+ *     - Primitives (Boolean, Int, Long, Double, Float, Byte, Short, Char) will be boxed when casted
+ *       to Any, and all the boxed classes implements Serializable.
+ * - This class implements Parcelable:
+ *     - Bundle
+ *
+ * Note: it is simplified copy of the array from SavedStateHandle (lifecycle-viewmodel-savedstate).
+ */
+private val AcceptableClasses = arrayOf(
+  Serializable::class.java,
+  Parcelable::class.java,
+  String::class.java,
+  SparseArray::class.java,
+  Binder::class.java,
+  Size::class.java,
+  SizeF::class.java
+)
+
+@Suppress("DEPRECATION")
+private fun Bundle.toMap(): Map<String, List<Any?>>? {
+  val map = mutableMapOf<String, List<Any?>>()
+  this.keySet().forEach { key ->
+    @Suppress("UNCHECKED_CAST")
+    val list = getParcelableArrayList<Parcelable?>(key) as ArrayList<Any?>
+    map[key] = list
+  }
+  return map
+}
+
+private fun Map<String, List<Any?>>.toBundle(): Bundle {
+  val bundle = Bundle()
+  forEach { (key, list) ->
+    val arrayList = if (list is ArrayList<Any?>) list else ArrayList(list)
+    @Suppress("UNCHECKED_CAST")
+    bundle.putParcelableArrayList(key, arrayList as ArrayList<Parcelable?>)
+  }
+  return bundle
+}

workflow-runtime/src/jvmMain/kotlin/com/squareup/workflow1/internal/compose/runtime/SerializableSaveableStateRegistry.kt

@@ -0,0 +1,72 @@
+package com.squareup.workflow1.internal.compose.runtime
+
+import androidx.compose.runtime.saveable.SaveableStateRegistry
+import com.squareup.workflow1.Snapshot
+import com.squareup.workflow1.parse
+import com.squareup.workflow1.readUtf8WithLength
+import com.squareup.workflow1.writeUtf8WithLength
+import okio.BufferedSink
+import okio.ByteString
+import java.io.ObjectInputStream
+import java.io.ObjectOutputStream
+import java.io.Serializable
+
+/**
+ * A [SaveableStateRegistry] that can save and restore anything that is [Serializable].
+ */
+internal class SerializableSaveableStateRegistry private constructor(
+  saveableStateRegistry: SaveableStateRegistry
+) : SaveableStateRegistry by saveableStateRegistry {
+  constructor(restoredValues: Map<String, List<Any?>>?) : this(
+    SaveableStateRegistry(restoredValues, ::canBeSavedAsSerializable)
+  )
+
+  constructor(snapshot: Snapshot) : this(snapshot.bytes.toMap())
+
+  fun toSnapshot(): Snapshot = Snapshot.write { sink ->
+    performSave().writeTo(sink)
+  }
+}
+
+/**
+ * Checks that [value] can be stored as a [Serializable].
+ */
+private fun canBeSavedAsSerializable(value: Any): Boolean {
+  if (value !is Serializable) return false
+
+  // lambdas in Kotlin implement Serializable, but will crash if you really try to save them.
+  // we check for both Function and Serializable (see kotlin.jvm.internal.Lambda) to support
+  // custom user defined classes implementing Function interface.
+  if (value is Function<*>) return false
+
+  return true
+}
+
+private fun ByteString.toMap(): Map<String, List<Any?>>? {
+  return parse { source ->
+    val size = source.readInt()
+    if (size == 0) return null
+
+    val inputStream = ObjectInputStream(source.inputStream())
+    buildMap(capacity = size) {
+      repeat(size) {
+        val key = source.readUtf8WithLength()
+
+        @Suppress("UNCHECKED_CAST")
+        val arrayList = inputStream.readObject() as ArrayList<Any?>
+        put(key, arrayList)
+      }
+    }
+  }
+}
+
+private fun Map<String, List<Any?>>.writeTo(sink: BufferedSink) {
+  sink.writeInt(values.size)
+  val outputStream = ObjectOutputStream(sink.outputStream())
+  values.forEach { (key, list) ->
+    val arrayList = if (list is ArrayList<Any?>) list else ArrayList(list)
+    sink.writeUtf8WithLength(key)
+    outputStream.writeObject(arrayList)
+    outputStream.flush()
+  }
+}