Please enable JavaScript.

Coggle requires JavaScript to display documents.

RxJava (API (Schedulers (api (computation(): ComputationScheduler, io():…

- - - - computation(): ComputationScheduler
      - io(): IoScheduler
      - newThread(): NewThreadScheduler
      - single(): SingleScheduler
      - trampoline(): TrampolineScheduler
      - from(Executor): Scheduler
    - - Worker
        
        api
        
        dispose()
      - api
        
        now(): long
        
        scheduleDirect(Runnable)
        
        scheduleDirect(Runnable, long, TimeUnit)
        
        schedulePeriodicallyDirect(Runnable, long, long, TimeUnit)
        
        createWorker(): Worker
      - impl
        
        ComputationScheduler
        
        notes
        
        Uses a pool of threads which size is equal to the available processor count
        
        IoScheduler
        
        notes
        
        Creates and caches threads in thread pools and reuses them if possible
        
        :warning: Can overload a system
        
        NewThreadScheduler
        
        notes
        
        :warning: Can overload a system
        
        Creates a new thread
        
        SingleScheduler
        
        notes
        
        Uses a single thread
        
        TrampolineScheduler
        
        notes
        
        Uses a single thread. Work is put in a queue and executed after the current unit of work is completed
  - - - impl
        
        Maybe
        
        api
        
        empty()
        
        toObservable()
        
        subscribe(MaybeObserver)
        
        Completable
        
        api
        
        fromRunnable(Runnable)
        
        subscribe(CompletableObserver)
        
        ConnectableObservable
        
        api
        
        connect()
        
        Single
        
        api
        
        toObservable()
        
        subscribe(SingleObserver)
        
        ObservableInterval
        
        notes
        
        is cold observable
        
        ignores subscribeOn; use scheduler-dependent factory instead
        
        ObservableFromFuture
        
        notes
        
        it is blocking; check the ref before use
        
        .get() is used under the hood
        
        ObservableEmpty
        
        notes
        
        RxJava null concept
        
        ObservableNever
        
        ObservableError
      - api
        
        subscribe(Observer): Disposable
        
        publish(): ConnectableObserver
        
        first(): Single
        
        firstElement(): Maybe
        
        subscribeOn(Scheduler)
        
        notes
        
        :warning: some observers (e.g.: interval) ignore subscribeOn
        
        the closest to sourse wins among multiple
        
        doOnDispose():Observable
        
        buffer()
        
        merge()
        
        :warning: order is not guaranteed; see concat
        
        mergeWith()
        
        mergeArray()
        
        concat()
        
        :warning: do not use with indefinite sourse; or put at the end
        
        concatMap()
        
        :warning: do not use with indefinite sourse; or put at the end
        
        flatMap()
        
        :warning: order is not guaranteed; see concatMap
        
        amb()
        
        zip()
        
        :warning: emisions of one observable waits for the pairs from another
  - - - api
        
        onError
        
        onComplete
        
        onNext
        
        onSubscribe
      - impl
        
        SingleObserver
        
        api
        
        onError
        
        onSubscribe
        
        onSuccess
        
        MaybeObserver
        
        api
        
        onError
        
        onComplete
        
        onSuccess
        
        CompletableObserver
        
        api
        
        onComplete
        
        onError
        
        onSubscribe