SeongUgJung

class ExampleViewModel(private val locationProvider: LocationProvider,
                      private val latLongSnapInteractor: LatLongSnapInteractor) { 
  fun onInit(): Observable<LatLong> {
    return locationProvider.latLong()
                 .doOnNext { latLongSnapInteractor.setLatLong(it) }
  }
}

SeongUgJung

class ExampleActivity: AppCompatActivity {
  @Inject lateinit var interactorController: InteractorController
  private var destroyDisposable: Disposable? = null
  private var pauseDisposable: Disposable? = null
  fun onCreated() {
    destroyDisposable = interactorController.onInit()
  }
  fun onDestroyed() {
    destroyDisposable?.dispose()
  }

SeongUgJung

class InteractorController(private val mapProvider:MapProvider, 
                           private varargs val interactors: Interactor) {
  fun onInit(): Completable {
    return mapProvider.initMap()
              .switchMapCompletable { map ->
                Observable.fromIterable(mapInteractors.asIterable())
                  .flatMapCompletable { mapInteractor ->
                     mapInteractor.onInit(map)
                  }
              }

SeongUgJung

class LatLongSnapInteractor : MapBehavior {
  private var latLong = ObservableField<LatLong>(LatLong.DEFAULT)
  
  fun setLatLong(latLong: LatLong) {
    this.latLong.set(latLong)
  }
  
  // will activate during resume-pause
  fun onVisible(map:Map): Completable {
    return latLong.asObservable()

SeongUgJung

class GoogleMapProvider: MapProvider {
  private val mapCache: BehaviorSubject<Map> = BehaviorSubject.createDefault(DEFAULT)

  override fun initMap(): Observable<Map> {
      return Observable.create(this::addMapFragment)
          .switchMapSingle(this::waitingForLoading)
          .doOnNext(mapCache::onNext)
  }

  override fun getMap(): Observable<Map> = mapCache.hide()

SeongUgJung

Single.create { emitter: SingleEmitter<Map> ->
    mapFragment.getMapAsync { map: GoogleMap? ->
        map?.let { actualMap ->
            actualMap.setOnMapLoadedCallback {
                emitter.onSuccess(GoogleMapImpl(actualMap))
            }
        } ?: run { emitter.tryOnError(IllegalStateException("No Map")) }
    }
}

SeongUgJung

emitter.setCancellable {
    fragmentManager.beginTransaction()
        .remove(mapFragment)
        .commitAllowingStateLoss()
    mapCache.onNext(DEFAULT)
}

SeongUgJung

val mapFragment = SupportMapFragment()
mapFragment.retainInstance = false
fragmentManager.beginTransaction()
    .replace(mapParams.resId, mapFragment)
    .commit()

SeongUgJung

interface MapProvider {
    fun initiateMap(): Observable<Map>
    fun getMap(): Observable<Map>
}

SeongUgJung

// 기존
lifecycleController.addObserver(onInit { Observable.create().subscribe() })

// 코드 추가
interface LifecycleDelegate { operator fun LifecycleObserver.unaryPlus() }
class LifecycleController : LifecycleDelegate {
  fun LifecycleObserver.unaryPlus() {
    this@LifecycleController.observers += this
  }
}