Kotlin recommande de désenregistrer un écouteur avec un SAM

Question

J'ai donc un interacteur qui effectue une opération d'insertion avec Realm, puis notifie que l'insertion est complétée par un RealChangeListener. Il est quelque chose comme ceci:

fun insertCar(item: Car) { 
     realm.doInTransaction { 
      val car = Car(...) 
      val copy = copyToRealm(car) 
      copy.addChangeListener(...) 
     } 
    } 

je peux le faire de cette façon:

fun insertCar(item: Car, listener: RealmChangeListener<Car>) { 
      realm.doInTransaction { 
       val car = Car(...) 
       val copy = copyToRealm(car) 
       copy.addChangeListener(listener) 
      } 
     } 

Et l'accès comme ceci:

realmInteractor.insertCar(item, RealmChangeListener { 
    // do something here 
}) 

Mais je n'ai aucune façon d'enlever cet écouteur

realmInteractor.insertCar(item, RealmChangeListener { 
    // do something here 
    it.removeChangeListener(this) 
}) 

this pointera vers la classe de son situé pas l'auditeur réel

Je peux aussi le faire:

fun insertCar(item: Car, doAfterChange (Car) -> Unit) { 
       realm.doInTransaction { 
        val car = Car(...) 
        val copy = copyToRealm(car) 
        copy.addChangeListener(RealmChangeListener{ 
        doAfterChange() 
        }) 
       } 
      } 

Mais j'ai un SAM dans un autre SAM (trop surpuissant imo)

je peux faire comme ceci:

fun insertCar(item: Car, listener: RealmChangeListener<Car>) { 
       realm.doInTransaction { 
        val car = Car(...) 
        val copy = copyToRealm(car) 
        copy.addChangeListener(listener) 
       } 
      } 

realmInteractor.insertCar(item, object : RealmChangeListener<Car> { 
         override fun onChange(element: Car?) { 
          ... 
          element?.removeChangeListener(this) 
         } 
        }) 

Qui fonctionne mais il est trop bavard.

Alors, comment gérez-vous cela et quelle est la meilleure approche?

Answer 1

Vous pouvez créer une méthode générique pour exécuter un écouteur d'exécution unique. Quelque chose du genre:

fun <T> createInRealm(objectFactory:() -> T, changeListener: (T) -> Unit) { 
    realm.doInTransaction { 
     val obj = objectFactory() 
     val copy = copyToRealm(obj) 
     copy.addChangeListener(object : RealmChangeListener<T> { 
      override fun onChange(element: T) { 
       changeListener() 
       element.removeChangeListener(this) 
      } 
     } 
    } 
}