Más sobre la empuñadura: componentes personalizados y rangos personalizados | Por Sajid Khan | Ingeniería de atención plena | Marzo de 2022

Si es nuevo en Hilt, comience leyendo nuestro blog anterior Fast Lane from Dagger2 to Hilt – Dependency Injection para obtener detalles básicos sobre Hilt y cómo configurarlo en su proyecto de Android.

Pasemos por alto lo que ya sabías en el último blog y saltemos a las nuevas funciones de Hilt.

@HiltViewModel

Anotación para preparar modelos de vista para inyección.

Puede renunciar a crear una ViewModelFactory para que su ViewModel inyecte esta anotación. ¡Pooh!

Así que en lugar de:

class ObviouslyCopyPastedViewModelFactory(
owner: SavedStateRegistryOwner,
private val repository: Repository,
defaultArgs: Bundle? = null
) : AbstractSavedStateViewModelFactory(owner, defaultArgs) {
override fun  create(
key: String, modelClass: Class, handle: SavedStateHandle
): T {
return someViewModel(
repository, handle
) as T
}
}

Solo harás:

@HiltViewModel
class someViewModel @Inject constructor() : ViewModel() {}

Se debe usar una única anotación @Inject en el constructor del objeto ViewModel.

Solo porque puedes, ¿deberías?

Se pueden construir componentes personalizados en Hilt, pero luego se debe manejar su ciclo de vida de instancia. No se recomiendan encarecidamente ya que introducen una sobrecarga y pueden complicar fácilmente el gráfico de dependencia. Lo mejor es utilizar los componentes proporcionados siempre que sea posible.

Puedes usarlos de las siguientes maneras:

Paso 1: tenga una interfaz anotada con @DefineComponent y pase el padre.Esto se usará como alcance en la anotación @InstallIn

@DefineComponent(parent = SingletonComponent::class)
interface MyCustomComponent

Paso 2: defina un constructor con @DefineComponent.Builder para que se puedan generar componentes

@DefineComponent.Builder
interface MyCustomComponentBuilder {
fun fooSeedData(@BindsInstance foo: Foo): MyCustomComponentBuilder
fun build(): MyCustomComponent
}

Paso 3: acceda al objeto usando @EntryPoint

@EntryPoint
@InstallIn(MyCustomComponent::class)
interface MyCustomEntryPoint {
fun getBar(): Bar
}
class CustomComponentManager @Inject constructor(
componentBuilder: MyCustomComponentBuilder) {
fun doSomething(foo: Foo) {
val component = componentBuilder.fooSeedData(foo).build();
val bar = EntryPoints.get(component, MyCustomEntryPoint::class.java).getBar()
// Hold on to the component instance if you need to!
}

Puede leer más sobre los componentes personalizados aquí.

De forma predeterminada, todos los enlaces en Hilt no tienen ámbito, lo que significa que se pasa una nueva instancia cada vez que se solicita un enlace.

Se pasa la misma instancia de vinculación cuando la vinculación se aplica al componente.

Hay varios tipos de alcances en Hilt:

@Único
para objetos

@ActividadRetenidaAlcance
Se utiliza para actividades y garantiza que los enlaces se conserven para los cambios de configuración

@ViewModelScoped
para el modelo de vista

@ActivityScoped
Se usa para actividades, pero los enlaces se destruyen en el cambio de configuración

@FragmentScoped
por fragmento

@ViewScoped
para ver

@ServiceScoped
para servicio

Cuando define un componente @ViewModelScoped, el enlace especificado existirá durante la vida útil del ViewModel.

Ejemplo simple de uso del alcance:

@Module
@InstallIn(ActivityComponent.class)
class Pizza {@Provides
@ActivityScoped
fun SliceOfPizza():Pizza{return Margherita()}

Después de implementar este alcance, podemos usar lo anterior en un fragmento como este:

class myFragment{@Inject somePizza:Pizza}

Lo anterior garantizará que el fragmento y la actividad vinculada al fragmento reciban la misma instancia de Pizza. Las diferentes actividades y fragmentos relacionados con la actividad correspondiente recibirán instancias de Pizza separadas.

Alerta de spoiler: En el caso más simple, Es mejor devolver un nuevo objeto en lugar de intentar devolver la misma instancia de objeto para obtener el mejor rendimiento.

Por ejemplo, cuando usamos @ActivityScoped, los fragmentos vinculados a diferentes actividades no obtienen la misma instancia del enlace de objeto como se ve arriba.Si hay muchos fragmentos y muchos objetos y el estado debe ser restauradopodemos imaginar cuánto afectará esto al rendimiento de la aplicación.