Java Code Examples for io.reactivex.schedulers.Schedulers#io()

public static Scheduler cast(ThreadMode threadMode) {
    Scheduler scheduler = null;
    switch (threadMode) {
        case COMPUTATION:
            scheduler = Schedulers.computation();
            break;
        case NEWTHREAD:
            scheduler = Schedulers.newThread();
            break;
        case MAIN:
            scheduler = AndroidSchedulers.mainThread();
            break;
        case IO:
            scheduler = Schedulers.io();
            break;
        default:
            scheduler = AndroidSchedulers.mainThread();
            break;
    }
    return scheduler;
}
 

@Provides
@CurrenciesActivityScope
@Override
public GetCurrenciesUseCase provideGetCurrenciesUseCase(final CurrencyRepository currencyRepository,
                                                        final PreferencesData preferencesData) {
    return new GetCurrenciesUseCase(Schedulers.io(), AndroidSchedulers.mainThread(),
            currencyRepository,
            preferencesData);
}
 

private Observable wrapObservableInBackground(Observable observable) {
  if (null == observable) {
    return null;
  }
  Scheduler scheduler = Schedulers.io();
  if (asynchronized) {
    observable = observable.subscribeOn(scheduler);
  }
  if (null != defaultCreator) {
    observable = observable.observeOn(scheduler);
  }
  return observable;
}
 

/**
 * Analise heart-beat sent from server (if any), to adjust the frequency.
 * Startup the heart-beat logic.
 */
private void heartBeatHandshake(final String heartBeatHeader) {
    if (heartBeatHeader != null) {
        // The heart-beat header is OPTIONAL
        final String[] heartbeats = heartBeatHeader.split(",");
        if (clientHeartbeatNew > 0) {
            //there will be heart-beats every MAX(<cx>,<sy>) milliseconds
            clientHeartbeat = Math.max(clientHeartbeatNew, Integer.parseInt(heartbeats[1]));
        }
        if (serverHeartbeatNew > 0) {
            //there will be heart-beats every MAX(<cx>,<sy>) milliseconds
            serverHeartbeat = Math.max(serverHeartbeatNew, Integer.parseInt(heartbeats[0]));
        }
    }
    if (clientHeartbeat > 0 || serverHeartbeat > 0) {
        scheduler = Schedulers.io();
        if (clientHeartbeat > 0) {
            //client MUST/WANT send heart-beat
            Log.d(TAG, "Client will send heart-beat every " + clientHeartbeat + " ms");
            scheduleClientHeartBeat();
        }
        if (serverHeartbeat > 0) {
            Log.d(TAG, "Client will listen to server heart-beat every " + serverHeartbeat + " ms");
            //client WANT to listen to server heart-beat
            scheduleServerHeartBeatCheck();

            // initialize the server heartbeat
            lastServerHeartBeat = System.currentTimeMillis();
        }
    }
}
 

/**
 * IO thread pool scheduler
 */
public Scheduler io() {
    return Schedulers.io();
}
 

public static Scheduler defaultBurstNodeServiceScheduler() {
    return Schedulers.io();
}
 

@Override
public Scheduler io() {
    return Schedulers.io();
}
 

@Override
public Scheduler io() {
    return Schedulers.io();
}
 

private static Rx production() {
  return new Rx(Schedulers.io(), AndroidSchedulers.mainThread(), Schedulers.newThread());
}
 

@Override
public Scheduler io() {
    return Schedulers.io();
}
 

@Provides
@CurrenciesActivityScope
@Override
public GetCurrenciesRatesDate provideGetCurrenciesRatesDate(final PreferencesData preferencesData) {
    return new GetCurrenciesRatesDate(Schedulers.io(), AndroidSchedulers.mainThread(), preferencesData);
}
 

@NonNull
public Scheduler io() {
  return Schedulers.io();
}
 

@Named(Constants.IO_SCHEDULER)
@Singleton
@Provides
public static Scheduler provideIoObserveScheduler() {
    return Schedulers.io();
}
 

@Override
@NonNull
public Scheduler io() {
    return Schedulers.io();
}
 

public static Scheduler io(Executor executor) {
    return executor != null ? Schedulers.from(executor) : Schedulers.io();
}
 

@NonNull
@Override
public Scheduler io() {
    return Schedulers.io();
}
 

@NonNull
protected Scheduler defaultRxScheduler() {
    return Schedulers.io();
}
 

/**
 * Provides the IO thread Scheduler.
 *
 * @return provides the IO thread Scheduler.
 */
@Override
public Scheduler provideIOScheduler() {
    return Schedulers.io();
}
 

/**
 * Open a custom {@link Book} with custom storage location path running its operations on
 * {@link Schedulers#io()}.
 * <p/>
 * Requires calling {@link RxPaperBook#init(Context)} at least once beforehand.
 *
 * @param path storage location
 * @param customBook book name
 * @return new RxPaperBook
 */
public static RxPaperBook withPath(String path, String customBook) {
    assertInitialized();
    return new RxPaperBook(path, customBook, Schedulers.io());
}
 

/**
 * Provides the IO thread Scheduler.
 *
 * @return provides the IO thread Scheduler.
 */
@Override
public Scheduler provideIOScheduler() {
    return Schedulers.io();
}