Internal changes

RELNOTES=n/a
PiperOrigin-RevId: 641978383

Author: hoisie

java/dagger/hilt/android/compose/BUILD

@@ -0,0 +1,117 @@
+# Copyright (C) 2023 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+#   Hilt Android classes for Jetpack Compose.
+
+load("//third_party/kotlin/build_extensions:rules.bzl", "kt_android_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+    name = "package_info",
+    srcs = ["package-info.java"],
+)
+
+kt_android_library(
+    name = "retained_view_model_manager",
+    srcs = ["RetainedViewModelManager.kt"],
+    visibility = ["//visibility:private"],
+    deps = [
+        ":remember_component_host",
+        "//:dagger_with_compiler",
+        "//third_party/java/androidx/activity",
+        "//third_party/java/androidx/lifecycle",
+    ],
+)
+
+kt_android_library(
+    name = "component_host_creator",
+    srcs = ["ComponentHostCreator.kt"],
+)
+
+kt_android_library(
+    name = "compose_component_host",
+    srcs = ["ComposeComponentHost.kt"],
+    exported_plugins = [
+        "//java/dagger/hilt/android/processor/internal/compose/composecomponenthost:processor",
+    ],
+    exports = [
+        ":component_host_creator",
+        ":compose_component_host_extras",
+        ":retained_view_model_manager",
+        "//:dagger_with_compiler",
+        "//java/dagger/hilt:install_in",
+        "//java/dagger/hilt/android/components",
+        "//java/dagger/hilt/android/compose/components",
+        "//java/dagger/hilt/android/compose/internal",
+        "//java/dagger/hilt/android/compose/internal/builders",
+        "//java/dagger/hilt/codegen:originating_element",
+        "//java/dagger/hilt/internal:generated_entry_point",
+    ],
+    deps = [
+        "//java/dagger/hilt:generates_root_input",
+    ],
+)
+
+kt_android_library(
+    name = "compose_component_host_extras",
+    srcs = ["ComposeComponentHostExtras.kt"],
+    deps = ["//java/dagger/hilt/android/internal"],
+)
+
+kt_android_library(
+    name = "compose_retained_lifecycle",
+    srcs = ["ComposeRetainedLifecycle.kt"],
+    deps = ["//java/dagger/hilt/android/lifecycle:retained_lifecycle"],
+)
+
+kt_android_library(
+    name = "compose_retained_provided",
+    srcs = ["ComposeRetainedProvided.kt"],
+    exported_plugins = [
+        "//java/dagger/hilt/android/processor/internal/compose/composeretainedprovided:processor",
+    ],
+    exports = [
+        "//:dagger_with_compiler",
+        "//java/dagger/hilt:install_in",
+        "//java/dagger/hilt/android/compose/components",
+        "//java/dagger/hilt/android/compose/internal/qualifiers",
+        "//java/dagger/hilt/codegen:originating_element",
+        "//java/dagger/hilt/internal:generated_entry_point",
+    ],
+)
+
+kt_android_library(
+    name = "remember_component_host",
+    srcs = ["RememberComponentHost.kt"],
+    deps = [
+        ":component_host_creator",
+        ":compose_component_host_extras",
+        ":compose_retained_lifecycle",
+        ":compose_retained_provided",
+        "//:dagger_with_compiler",
+        "//java/dagger/hilt:entry_point",
+        "//java/dagger/hilt:install_in",
+        "//java/dagger/hilt/android/compose/components",
+        "//java/dagger/hilt/android/compose/internal",
+        "//java/dagger/hilt/android/compose/scopes",
+        "//java/dagger/hilt/android/internal",
+        "//java/dagger/hilt/android/internal/lifecycle",
+        "//third_party/java/androidx/compose/runtime",
+        "//third_party/java/androidx/compose/ui",
+        "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+        "@maven//:androidx_lifecycle_lifecycle_viewmodel_compose",
+    ],
+)

java/dagger/hilt/android/compose/ComponentHostCreator.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.compose
+
+/**
+ * Provides a way to retrieve the given ComponentHost type from an appropriate component.
+ *
+ * This class should never be used on its own. It should always be used with [rememberComponentHost]
+ * to ensure that the lifecycle of the given host is correct.
+ *
+ * The annotation processor will generate appropriate classes to ensure that it's possible to inject
+ * `ComponentHostCreator<SpecificHost>`.
+ *
+ * @param HostT the type annotated with [ComposeComponentHost], which is used here to differentiate one
+ *   ComponentHostCreator from another.
+ */
+interface ComponentHostCreator<out HostT>

java/dagger/hilt/android/compose/ComposeComponentHost.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.compose
+
+import dagger.hilt.GeneratesRootInput
+
+/**
+ * Annotation used to indicate that the annotated type hosts the Compose and ComposeRetained Dagger
+ * components.
+ *
+ * See the following example on how to use `@ComposeComponentHost`:
+ * ```
+ * /** Hosts the MyScreen Composable. Hilt_MyHost is generated and must be the super type. */
+ * @ComposeComponentHost
+ * class MyHost @Inject internal constructor(dependency: MyInjectedDependency) : Hilt_MyHost {
+ *
+ *   @Composable
+ *   fun MyScreen(modifier: Modifier = Modifier) {
+ *     // Define MyScreen, using data from the injected dependency
+ *   }
+ * }
+ * ```
+ *
+ * `MyHost` is annotated with `@ComposeComponentHost`, so Hilt generates a
+ * `ComponentHostCreator<MyHost>` and provides a binding for it. `MyHost` is injected and used as
+ * follows:
+ * ```
+ * @AndroidEntryPoint(ComponentActivity::class)
+ * class HomeActivity: Hilt_HomeActivity() {
+ *   @Inject lateinit var myHostCreator: ComponentHostCreator<MyHost>
+ *
+ *   override fun onCreate(bundle: Bundle?) {
+ *     super.onCreate(bundle)
+ *     setContent {
+ *       // myHostCreator must be used with rememberComponentHost to have the correct lifecycle
+ *       val myHost = rememberComponentHost(myHostCreator)
+ *       myHost.MyScreen()
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * As with other Hilt components, bindings can be scoped to either the ComposeComponent or
+ * ComposeRetainedComponent by using the appropriate scope annotation:
+ * [dagger.hilt.android.compose.scopes.ComposeScoped] for the ComposeComponent and
+ * [dagger.hilt.android.compose.scopes.ComposeRetainedScoped] for the ComposeRetainedComponent.
+ * Annotating a binding as such results in Hilt providing the same instance of that binding every
+ * time it's requested in the corresponding component. For example:
+ * ```
+ * /**
+ *  * Because ComposeScopedDependency is @ComposeScoped,
+ *  * firstDependency.scopedDependency === secondDependency.scopedDependency.
+ *  */
+ * @ComposeComponentHost
+ * class MyHost @Inject internal constructor(
+ *   private val firstDependency: FirstDependency,
+ *   private val secondDependency: SecondDependency
+ * ) {...}
+ *
+ * class FirstDependency @Inject constructor(private val scopedDependency: ComposeScopedDependency)
+ * class SecondDependency @Inject constructor(private val scopedDependency: ComposeScopedDependency)
+ *
+ * @ComposeScoped
+ * class ComposeScopedDependency @Inject constructor()
+ * ```
+ *
+ * The equivalent applies to `@ComposeRetainedScoped` annotated bindings, however additional
+ * machinery is needed. See the documentation on
+ * [dagger.hilt.android.compose.ComposeRetainedProvided] for details.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.BINARY)
+@GeneratesRootInput
+annotation class ComposeComponentHost

java/dagger/hilt/android/compose/ComposeComponentHostExtras.kt

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.compose
+
+import dagger.hilt.android.internal.ThreadUtil
+
+/**
+ * Read only version of extras provided to a ComposeComponentHost.
+ *
+ * Use [buildComposeComponentHostExtras] to create an instance of ComposeComponentHostExtras.
+ *
+ * ComposeComponentHostExtras support a specific use case and should not replace alternate means of
+ * providing objects to a host:
+ * - Objects that are part of the Dagger graph should be injected directly where they're used.
+ * - Objects that aren't part of the Dagger graph can be provided through ComposeComponentHostExtras
+ *   if they're used in enough places to benefit from making them globally accessible in the
+ *   ComposeComponent and ComposeRetainedComponent.
+ * - Objects that are not used in enough places to warrant use of ComposeComponentHostExtras can be
+ *   passed as parameters to `@Composable` functions.
+ */
+class ComposeComponentHostExtras internal constructor(private val keyToExtra: Map<Key<*>, Any>) {
+
+  /** Returns the argument associated with the given key, if available. */
+  @Suppress("UNCHECKED_CAST") // extras can only be inserted with a type that matches the key
+  fun <T> get(key: Key<T>): T? = keyToExtra[key] as T
+
+  /**
+   * Represents the key for a given argument.
+   *
+   * Key subclasses require no implementation and should generally be implemented as a Kotlin
+   * object. The generic type parameter should be set as the type of the argument. Example key for a
+   * specific argument of type String:
+   * ```kotlin
+   * object MyStringKey: Key<String>
+   * ```
+   */
+  interface Key<out T>
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is ComposeComponentHostExtras) return false
+    return keyToExtra == other.keyToExtra
+  }
+
+  override fun hashCode(): Int = keyToExtra.hashCode()
+}
+
+/**
+ * Builds a new instance of [ComposeComponentHostExtras] by populating a
+ * [MutableComposeComponentHostExtras] instance using the given [builderAction].
+ *
+ * Build and use the extras in a host with the following:
+ * ```kotlin
+ * @Composable
+ * fun MyContent() {
+ *   val extras = buildComposeComponentHostExtras {
+ *     put(MyStringKey, "someStringExtra")
+ *     put(MyIntKey, 5)
+ *     put(MyBooleanKey, true)
+ *   }
+ *
+ *   val host = rememberComponentHost(myHost, extras)
+ * }
+ * ```
+ */
+fun buildComposeComponentHostExtras(
+  builderAction: MutableComposeComponentHostExtras.() -> Unit
+): ComposeComponentHostExtras {
+  ThreadUtil.ensureMainThread()
+  return MutableComposeComponentHostExtras().apply { this.builderAction() }.build()
+}
+
+/**
+ * The write-only version of extras provided to a ComposeComponentHost.
+ *
+ * For all [put] methods, calling the method multiple times with the same key will overwrite the
+ * stored value. For example:
+ * ```kotlin
+ * @Composable fun Content() {
+ *   val extras = buildComposeComponentHostExtras {
+ *     put(SomeStringKey, "hello") // "hello" is associated with SomeStringKey
+ *     put(SomeStringKey, "world") // now "world" is associated with SomeStringKey
+ *   }
+ * }
+ * ```
+ */
+class MutableComposeComponentHostExtras internal constructor() {
+  private val keyToExtra: MutableMap<ComposeComponentHostExtras.Key<*>, Any> = mutableMapOf()
+
+  fun put(key: ComposeComponentHostExtras.Key<Int>, value: Int) {
+    keyToExtra[key] = value
+  }
+
+  fun put(key: ComposeComponentHostExtras.Key<Long>, value: Long) {
+    keyToExtra[key] = value
+  }
+
+  fun put(key: ComposeComponentHostExtras.Key<Float>, value: Float) {
+    keyToExtra[key] = value
+  }
+
+  fun put(key: ComposeComponentHostExtras.Key<Double>, value: Double) {
+    keyToExtra[key] = value
+  }
+
+  fun put(key: ComposeComponentHostExtras.Key<Boolean>, value: Boolean) {
+    keyToExtra[key] = value
+  }
+
+  fun put(key: ComposeComponentHostExtras.Key<String>, value: String) {
+    keyToExtra[key] = value
+  }
+
+  // TODO: b/303256918 - Also support immutable data types and protos
+
+  internal fun build() = ComposeComponentHostExtras(keyToExtra)
+}