Generate fromSavedStateHandle function for Kotlin args

androidx · simonschiller · Jan 22, 2021 · Jan 22, 2021 · Jan 22, 2021 · Jan 23, 2021
commit 07894f0d0cb66e91b1b66a0cc04430af8c78646d
@@ -267,6 +267,52 @@ class KotlinNavWriter(private val useAndroidX: Boolean = true) : NavWriter<Kotli
             addStatement("return·%T(${tempVariables.joinToString(", ") { it }})", className)
         }.build()
 
+        val fromSavedStateHandleFunSpec = FunSpec.builder("fromSavedStateHandle").apply {
+            addAnnotation(JvmStatic::class)
+            returns(className)
+            val savedStateParamName = "savedStateHandle"
+            addParameter(savedStateParamName, SAVED_STATE_HANDLE_CLASSNAME)
+            val tempVariables = destination.args.map { arg ->
+                val tempVal = "__${arg.sanitizedName}"
+                addStatement(
+                    "val %L : %T",
+                    tempVal,
+                    arg.type.typeName().copy(nullable = true)
+                )
+                beginControlFlow("if (%L.contains(%S))", savedStateParamName, arg.name)
+                addStatement("%L = %L[%S]", tempVal, savedStateParamName, arg.name)
+                if (!arg.isNullable) {
+                    beginControlFlow("if (%L == null)", tempVal)
+                    val errorMessage = if (arg.type.allowsNullable()) {
+                        "Argument \"${arg.name}\" is marked as non-null but was passed a null value"
+                    } else {
+                        "Argument \"${arg.name}\" of type ${arg.type} does not support null values"
+                    }
+                    addStatement(
+                        "throw·%T(%S)",
+                        IllegalArgumentException::class.asTypeName(),
+                        errorMessage
+                    )
+                    endControlFlow()
+                }
+                nextControlFlow("else")
+                val defaultValue = arg.defaultValue
+                if (defaultValue != null) {
+                    addStatement("%L = %L", tempVal, arg.defaultValue.write())
+                } else {
+                    addStatement(
+                        "throw·%T(%S)",
+                        IllegalArgumentException::class.asTypeName(),
+                        "Required argument \"${arg.name}\" is missing and does not have an " +
+                            "android:defaultValue"
+                    )
+                }
+                endControlFlow()
+                return@map tempVal
+            }
+            addStatement("return·%T(${tempVariables.joinToString(", ") { it }})", className)
+        }.build()
+
         val typeSpec = TypeSpec.classBuilder(className)
             .addSuperinterface(NAV_ARGS_CLASSNAME)
             .addModifiers(KModifier.DATA)
@@ -283,6 +329,7 @@ class KotlinNavWriter(private val useAndroidX: Boolean = true) : NavWriter<Kotli
             .addType(
                 TypeSpec.companionObjectBuilder()
                     .addFunction(fromBundleFunSpec)
+                    .addFunction(fromSavedStateHandleFunSpec)
                     .build()
             )
             .build()

@@ -62,6 +62,8 @@ internal val ACTION_ONLY_NAV_DIRECTION_CLASSNAME: ClassName =
     ClassName("androidx.navigation", "ActionOnlyNavDirections")
 internal val NAV_ARGS_CLASSNAME: ClassName = ClassName("androidx.navigation", "NavArgs")
 internal val BUNDLE_CLASSNAME: ClassName = ClassName("android.os", "Bundle")
+internal val SAVED_STATE_HANDLE_CLASSNAME: ClassName =
+    ClassName("androidx.lifecycle", "SavedStateHandle")
 
 internal val PARCELABLE_CLASSNAME = ClassName("android.os", "Parcelable")
 internal val SERIALIZABLE_CLASSNAME = ClassName("java.io", "Serializable")

@@ -3,6 +3,7 @@ package a.b
 import android.content.pm.ActivityInfo
 import android.os.Bundle
 import android.os.Parcelable
+import androidx.lifecycle.SavedStateHandle
 import androidx.navigation.NavArgs
 import java.io.Serializable
 import java.lang.IllegalArgumentException
@@ -146,5 +147,98 @@ public data class MainFragmentArgs(
       return MainFragmentArgs(__main, __optional, __reference, __referenceZeroDefaultValue,
           __floatArg, __floatArrayArg, __objectArrayArg, __boolArg, __optionalParcelable, __enumArg)
     }
+
+    @JvmStatic
+    public fun fromSavedStateHandle(savedStateHandle: SavedStateHandle): MainFragmentArgs {
+      val __main : String?
+      if (savedStateHandle.contains("main")) {
+        __main = savedStateHandle["main"]
+        if (__main == null) {
+          throw IllegalArgumentException("Argument \"main\" is marked as non-null but was passed a null value")
+        }
+      } else {
+        throw IllegalArgumentException("Required argument \"main\" is missing and does not have an android:defaultValue")
+      }
+      val __optional : Int?
+      if (savedStateHandle.contains("optional")) {
+        __optional = savedStateHandle["optional"]
+        if (__optional == null) {
+          throw IllegalArgumentException("Argument \"optional\" of type integer does not support null values")
+        }
+      } else {
+        __optional = -1
+      }
+      val __reference : Int?
+      if (savedStateHandle.contains("reference")) {
+        __reference = savedStateHandle["reference"]
+        if (__reference == null) {
+          throw IllegalArgumentException("Argument \"reference\" of type reference does not support null values")
+        }
+      } else {
+        __reference = R.drawable.background
+      }
+      val __referenceZeroDefaultValue : Int?
+      if (savedStateHandle.contains("referenceZeroDefaultValue")) {
+        __referenceZeroDefaultValue = savedStateHandle["referenceZeroDefaultValue"]
+        if (__referenceZeroDefaultValue == null) {
+          throw IllegalArgumentException("Argument \"referenceZeroDefaultValue\" of type reference does not support null values")
+        }
+      } else {
+        __referenceZeroDefaultValue = 0
+      }
+      val __floatArg : Float?
+      if (savedStateHandle.contains("floatArg")) {
+        __floatArg = savedStateHandle["floatArg"]
+        if (__floatArg == null) {
+          throw IllegalArgumentException("Argument \"floatArg\" of type float does not support null values")
+        }
+      } else {
+        __floatArg = 1F
+      }
+      val __floatArrayArg : FloatArray?
+      if (savedStateHandle.contains("floatArrayArg")) {
+        __floatArrayArg = savedStateHandle["floatArrayArg"]
+        if (__floatArrayArg == null) {
+          throw IllegalArgumentException("Argument \"floatArrayArg\" is marked as non-null but was passed a null value")
+        }
+      } else {
+        throw IllegalArgumentException("Required argument \"floatArrayArg\" is missing and does not have an android:defaultValue")
+      }
+      val __objectArrayArg : Array<ActivityInfo>?
+      if (savedStateHandle.contains("objectArrayArg")) {
+        __objectArrayArg = savedStateHandle["objectArrayArg"]
+        if (__objectArrayArg == null) {
+          throw IllegalArgumentException("Argument \"objectArrayArg\" is marked as non-null but was passed a null value")
+        }
+      } else {
+        throw IllegalArgumentException("Required argument \"objectArrayArg\" is missing and does not have an android:defaultValue")
+      }
+      val __boolArg : Boolean?
+      if (savedStateHandle.contains("boolArg")) {
+        __boolArg = savedStateHandle["boolArg"]
+        if (__boolArg == null) {
+          throw IllegalArgumentException("Argument \"boolArg\" of type boolean does not support null values")
+        }
+      } else {
+        __boolArg = true
+      }
+      val __optionalParcelable : ActivityInfo?
+      if (savedStateHandle.contains("optionalParcelable")) {
+        __optionalParcelable = savedStateHandle["optionalParcelable"]
+      } else {
+        __optionalParcelable = null
+      }
+      val __enumArg : AccessMode?
+      if (savedStateHandle.contains("enumArg")) {
+        __enumArg = savedStateHandle["enumArg"]
+        if (__enumArg == null) {
+          throw IllegalArgumentException("Argument \"enumArg\" is marked as non-null but was passed a null value")
+        }
+      } else {
+        __enumArg = AccessMode.READ
+      }
+      return MainFragmentArgs(__main, __optional, __reference, __referenceZeroDefaultValue,
+          __floatArg, __floatArrayArg, __objectArrayArg, __boolArg, __optionalParcelable, __enumArg)
+    }
   }
 }
@@ -1,6 +1,7 @@
 package a.b
 
 import android.os.Bundle
+import androidx.lifecycle.SavedStateHandle
 import androidx.navigation.NavArgs
 import kotlin.jvm.JvmStatic
 
@@ -19,5 +20,11 @@ public data class
       bundle.setClassLoader(ReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongNameFragmentArgs::class.java.classLoader)
       return ReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongNameFragmentArgs()
     }
+
+    @JvmStatic
+    public fun fromSavedStateHandle(savedStateHandle: SavedStateHandle):
+        ReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongNameFragmentArgs
+        =
+        ReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongNameFragmentArgs()
   }
 }