How to use org.greenrobot.greendao.rx

protected <R> Observable<R> wrap(Callable<R> callable) {
  return wrap(RxUtils.fromCallable(callable));
}

/**
 * Rx version of {@link AbstractDao#count()} returning an Observable.
 */
@Experimental
public Observable<Long> count() {
  return wrap(new Callable<Long>() {
    @Override
    public Long call() throws Exception {
      return dao.count();
    }
  });
}

/**
 * Rx version of {@link Query#list()} returning an Observable.
 */
@Experimental
public Observable<List<T>> list() {
  return wrap(new Callable<List<T>>() {
    @Override
    public List<T> call() throws Exception {
      return query.forCurrentThread().list();
    }
  });
}

/**
 * Rx version of {@link AbstractDaoSession#callInTx(Callable)} returning an Observable.
 */
@Experimental
public <T> Observable<T> call(final Callable<T> callable) {
  return wrap(new Callable<T>() {
    @Override
    public T call() throws Exception {
      return daoSession.callInTx(callable);
    }
  });
}

/**
 * The returned {@link RxTransaction} allows DB transactions using Rx Observables without any Scheduler set for
 * subscribeOn.
 *
 * @see #rxTx()
 */
@Experimental
public RxTransaction rxTxPlain() {
  if (rxTxPlain == null) {
    rxTxPlain = new RxTransaction(this);
  }
  return rxTxPlain;
}

/**
 * DO NOT USE.
 * The returned {@link RxTransaction} allows getting query results using Rx Observables without any Scheduler set
 * for subscribeOn.
 *
 * @see #__InternalRx()
 */
@Internal
public RxQuery __internalRxPlain() {
  if (rxTxPlain == null) {
    rxTxPlain = new RxQuery(this);
  }
  return rxTxPlain;
}

/**
 * The returned RxDao is a special DAO that let's you interact with Rx Observables without any Scheduler set
 * for subscribeOn.
 *
 * @see #rx()
 */
@Experimental
public RxDao<T, K> rxPlain() {
  if (rxDaoPlain == null) {
    rxDaoPlain = new RxDao<>(this);
  }
  return rxDaoPlain;
}

/**
 * Rx version of {@link AbstractDao#deleteAll()} returning an Observable.
 */
@Experimental
public Observable<Void> deleteAll() {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteAll();
      return null;
    }
  });
}

/**
 * Rx version of {@link Query#unique()} returning an Observable.
 */
@Experimental
public Observable<T> unique() {
  return wrap(new Callable<T>() {
    @Override
    public T call() throws Exception {
      return query.forCurrentThread().unique();
    }
  });
}

/**
 * Rx version of {@link AbstractDao#delete(Object)} returning an Observable.
 */
@Experimental
public Observable<Void> delete(final T entity) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.delete(entity);
      return null;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#deleteInTx(Iterable)} returning an Observable.
 */
@Experimental
public Observable<Void> deleteInTx(final Iterable<T> entities) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteInTx(entities);
      return null;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#loadAll()} returning an Observable.
 */
@Experimental
public Observable<T> load(final K key) {
  return wrap(new Callable<T>() {
    @Override
    public T call() throws Exception {
      return dao.load(key);
    }
  });
}

/**
 * Rx version of {@link AbstractDao#loadAll()} returning an Observable.
 */
@Experimental
public Observable<List<T>> loadAll() {
  return wrap(new Callable<List<T>>() {
    @Override
    public List<T> call() throws Exception {
      return dao.loadAll();
    }
  });
}

/**
 * Rx version of {@link AbstractDao#deleteByKeyInTx(Object[])} returning an Observable.
 */
@Experimental
public Observable<Void> deleteByKeyInTx(final K... keys) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteByKeyInTx(keys);
      return null;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#deleteByKey(Object)} returning an Observable.
 */
@Experimental
public Observable<Void> deleteByKey(final K key) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteByKey(key);
      return null;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#save(Object)} returning an Observable.
 * Note that the Observable will emit the given entity back to its subscribers.
 */
@Experimental
public Observable<T> save(final T entity) {
  return wrap(new Callable<T>() {
    @Override
    public T call() throws Exception {
      dao.save(entity);
      return entity;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#insert(Object)} returning an Observable.
 * Note that the Observable will emit the given entity back to its subscribers.
 */
@Experimental
public Observable<T> insert(final T entity) {
  return wrap(new Callable<T>() {
    @Override
    public T call() throws Exception {
      dao.insert(entity);
      return entity;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#updateInTx(Object[])} returning an Observable.
 * Note that the Observable will emit the given entities back to its subscribers.
 */
@Experimental
public Observable<Object[]> updateInTx(final T... entities) {
  return wrap(new Callable<Object[]>() {
    @Override
    public Object[] call() throws Exception {
      dao.updateInTx(entities);
      return entities;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#deleteByKeyInTx(Iterable)} returning an Observable.
 */
@Experimental
public Observable<Void> deleteByKeyInTx(final Iterable<K> keys) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteByKeyInTx(keys);
      return null;
    }
  });
}

/**
 * Rx version of {@link AbstractDao#deleteInTx(Object[])} returning an Observable.
 */
@Experimental
public Observable<Void> deleteInTx(final T... entities) {
  return wrap(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      dao.deleteInTx(entities);
      return null;
    }
  });
}