Restablecimiento de valores y properties diferidas de Kotlin: un delegado perezoso reiniciable

Así que uso kotlin para Android, y al inflar las vistas, tiendo a hacer lo siguiente:

 private val recyclerView by lazy { find<RecyclerView>(R.id.recyclerView) } 

Este método funcionará. Sin embargo, hay un caso en el que se producirá un error en la aplicación. Si se trata de un fragment y el fragment va a la columna posterior, onCreateView volverá a llamar y se volverá a crear la jerarquía de vista del fragment. Lo que significa que el reciclador Iniciado perezoso señalará una vista anterior que ya no existe.

Una solución es así:

 private lateinit var recyclerView: RecyclerView 

Y inicialice todas las properties dentro onCreateView .

Mi pregunta es, ¿hay alguna manera de restablecer las properties perezosas para que puedan ser inicializadas de nuevo? Me gusta el hecho de que las inicializaciones se hacen en la parte superior de una class, ayuda a mantener el código organizado. El problema específico se encuentra en esta pregunta: kotlin android fragment empty recycler view after back

Aquí hay una versión rápida de un perezoso reajustable, podría ser más elegante y necesita una verificación doble para la security del hilo, pero esta es básicamente la idea. Necesita algo para administrar (realizar un seguimiento) de los delegates perezosos para que pueda solicitar el reinicio, y luego cosas que se pueden administrar y restablecer. Esto envuelve lazy() en estas classs de gestión.

Así es como se verá tu class final , como un ejemplo:

 class Something { val lazyMgr = resettableManager() val prop1: String by resettableLazy(lazyMgr) { ... } val prop2: String by resettableLazy(lazyMgr) { ... } val prop3: String by resettableLazy(lazyMgr) { ... } } 

Luego, para hacer que los perezosos vuelvan a los nuevos valores la próxima vez que se acceda a ellos:

 lazyMgr.reset() // prop1, prop2, and prop3 all will do new lazy values on next access 

La implementación del perezoso reiniciable:

 class ResettableLazyManager { // we synchronize to make sure the timing of a reset() call and new inits do not collide val managedDelegates = LinkedList<Resettable>() fun register(managed: Resettable) { synchronized (managedDelegates) { managedDelegates.add(managed) } } fun reset() { synchronized (managedDelegates) { managedDelegates.forEach { it.reset() } managedDelegates.clear() } } } interface Resettable { fun reset() } class ResettableLazy<PROPTYPE>(val manager: ResettableLazyManager, val init: ()->PROPTYPE): Resettable { @Volatile var lazyHolder = makeInitBlock() operator fun getValue(thisRef: Any?, property: KProperty<*>): PROPTYPE { return lazyHolder.value } override fun reset() { lazyHolder = makeInitBlock() } fun makeInitBlock(): Lazy<PROPTYPE> { return lazy { manager.register(this) init() } } } fun <PROPTYPE> resettableLazy(manager: ResettableLazyManager, init: ()->PROPTYPE): ResettableLazy<PROPTYPE> { return ResettableLazy(manager, init) } fun resettableManager(): ResettableLazyManager = ResettableLazyManager() 

Y algunas testings unitarias para estar seguro:

 class Tester { @Test fun testResetableLazy() { class Something { var seed = 1 val lazyMgr = resettableManager() val x: String by resettableLazy(lazyMgr) { "x ${seed}" } val y: String by resettableLazy(lazyMgr) { "y ${seed}" } val z: String by resettableLazy(lazyMgr) { "z $x $y"} } val s = Something() val x1 = sx val y1 = sy val z1 = sz assertEquals(x1, sx) assertEquals(y1, sy) assertEquals(z1, sz) s.seed++ // without reset nothing should change assertTrue(x1 === sx) assertTrue(y1 === sy) assertTrue(z1 === sz) s.lazyMgr.reset() s.seed++ // because of reset the values should change val x2 = sx val y2 = sy val z2 = sz assertEquals(x2, sx) assertEquals(y2, sy) assertEquals(z2, sz) assertNotEquals(x1, x2) assertNotEquals(y1, y2) assertNotEquals(z1, z2) s.seed++ // but without reset, nothing should change assertTrue(x2 === sx) assertTrue(y2 === sy) assertTrue(z2 === sz) } } 

Tenía la misma tarea, y esto es lo que utilicé:

 import kotlin.properties.ReadOnlyProperty import kotlin.reflect.KProperty class SingletonLazy<T : Any>(val initBlock: () -> T, val clazz: Class<T>) { operator fun <R> provideDelegate(ref: R, prop: KProperty<*>): ReadOnlyProperty<R, T> = delegate() @Suppress("UNCHECKED_CAST") private fun <R> delegate(): ReadOnlyProperty<R, T> = object : ReadOnlyProperty<R, T> { override fun getValue(thisRef: R, property: KProperty<*>): T { val hash = clazz.hashCode() val cached = singletonsCache[hash] if (cached != null && cached.javaClass == clazz) return cached as T return initBlock().apply { singletonsCache[hash] = this } } } } private val singletonsCache = HashMap<Int, Any>() fun <T> clearSingleton(clazz: Class<T>) : Boolean { val hash = clazz.hashCode() val result = singletonsCache[hash] if (result?.javaClass != clazz) return false singletonsCache.remove(hash) return true } inline fun <reified T : Any> singletonLazy(noinline block: () -> T): SingletonLazy<T> = SingletonLazy(block, T::class.java) 

uso:

 val cat: Cat by singletonLazy { Cat() } fun main(args: Array<String>) { cat println(clearSingleton(Cat::class.java)) cat // cat will be created one more time println(singletonsCache.size) } class Cat { init { println("creating cat") } } 

Por supuesto, puede tener sus propias estrategias de almacenamiento en caching.