Java RxLogObservable类代码示例

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Pair<List<Device>, List<Position>>> getDevicesAndPositions() {
    return mStorageService.getDevicesList()
            .flatMap(new Func1<List<Device>, Observable<Pair<List<Device>, List<Position>>>>() {
                @Override
                public Observable<Pair<List<Device>, List<Position>>> call(List<Device> devices) {
                    List<Long> ids = new ArrayList<>();
                    for (Device device: devices) {
                        if (device.getPositionId() != null && device.getPositionId() > 0) {
                            ids.add(device.getPositionId());
                        }
                    }
                    return mStorageService.getPositions(ids)
                           .map(positions -> Pair.create(devices, positions));
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<List<Position>> getPositions(List<Long> ids) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < ids.size(); i ++) {
        builder.append("_id = ?");
        if (i != ids.size() - 1) {
            builder.append(" OR ");
        }
    }

    return storIOSQLite
            .get()
            .listOfObjects(Position.class)
            .withQuery(Query.builder().table(PositionsTable.TABLE)
                    .where(builder.toString())
                    .whereArgs(ids)
                    .build()
            )
            .prepare()
            .asRxObservable();
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<List<User>> getUsers(Integer lastIdQueried, final boolean refresh) {
    lastIdQueried = lastIdQueried == null ? FIRST_ID_QUERIED : lastIdQueried;

    Observable<List<User>> loader = restApi.getUsers(lastIdQueried, USERS_PER_PAGE).map(response -> {
        handleError(response);
        return response.body();
    });


    if (lastIdQueried == FIRST_ID_QUERIED) {
        loader = rxProviders.getUsers(loader, new DynamicKey(lastIdQueried), new EvictProvider(refresh));
    }

    return loader;
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
/**
 * 获取启动页图片
 */
@RxLogObservable
Observable<Bitmap> getStartImage() {
    return Observable.fromCallable(new Callable<Bitmap>() {
        @Override
        public Bitmap call() throws Exception {
            File dir = context.getFilesDir();
            mImageFile = new File(dir, SPLASH_IMAGE_FILEPATH);
            if (mImageFile.exists()) {
                return BitmapFactory.decodeFile(mImageFile.getAbsolutePath());
            } else {
                return BitmapFactory.decodeResource(context.getResources(), R.drawable.ic_launch_bg);
            }
        }
    });
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
@Override public Observable<List<UserEntity>> userEntityList() {
  return Observable.create(subscriber -> {
    Log.i("AAA","INSIDE CALL:"+Thread.currentThread().getName());  // inside call---> same thread
    if (isThereInternetConnection()) {
      try {
        String responseUserEntities = getUserEntitiesFromApi();
        if (responseUserEntities != null) {
          subscriber.onNext(userEntityJsonMapper.transformUserEntityCollection(
              responseUserEntities));
          subscriber.onCompleted();
        } else {
          subscriber.onError(new NetworkConnectionException());
        }
      } catch (Exception e) {
        subscriber.onError(new NetworkConnectionException(e.getCause()));
      }
    } else {
      subscriber.onError(new NetworkConnectionException());
    }
  });
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
@Override public Observable<UserEntity> userEntityById(final int userId) {
  return Observable.create(subscriber -> {
    if (isThereInternetConnection()) {
      try {
        String responseUserDetails = getUserDetailsFromApi(userId);
        if (responseUserDetails != null) {
          subscriber.onNext(userEntityJsonMapper.transformUserEntity(responseUserDetails));
          subscriber.onCompleted();
        } else {
          subscriber.onError(new NetworkConnectionException());
        }
      } catch (Exception e) {
        subscriber.onError(new NetworkConnectionException(e.getCause()));
      }
    } else {
      subscriber.onError(new NetworkConnectionException());
    }
  });
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable @Override public Observable<Beer> call(Beer beer) {
  return Observable.create(new Observable.OnSubscribe<Beer>() {
    @Override public void call(Subscriber<? super Beer> subscriber) {
      try {
        Beer createdBeer = mBeerDao.create(beer);
        if (!subscriber.isUnsubscribed()) {
          subscriber.onNext(createdBeer);
        }
        subscriber.onCompleted();
      } catch (DBOperationException e) {
        e.printStackTrace();
        Observable.error(new Throwable("Error occurs when adding beer"));
      }
    }
  });
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable private Observable<List<ApplicationInfo>> getAllApplications() {
  return Observable.from(
      context.getPackageManager().getInstalledApplications(PackageManager.GET_META_DATA))
      .observeOn(Schedulers.computation())
      .filter(Utils.removeSelfPackage(context))
      .filter(Utils.removeLaunchers(context))
      .filter(Utils.removeSystemApps())
      .toSortedList(Utils.getApplicationSortFunction(context))
      .observeOn(AndroidSchedulers.mainThread())
      .cache();
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Void> signOut() {
    return mNetworkService.deleteSession()
            .flatMap(new Func1<Void, Observable<Void>>() {
                @Override
                public Observable<Void> call(Void aVoid) {
                    return mStorageService.drop();
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Server> getServer() {
    return mNetworkService.getServer()
            .flatMap(new Func1<Server, Observable<Server>>() {
                @Override
                public Observable<Server> call(Server server) {
                    return mStorageService.saveServer(server);
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Pair<List<Device>, List<Device>>> getDevices(boolean admin, long userId) {
    return Observable.zip(
            mNetworkService.getDevices(admin),
            mNetworkService.getDevices(userId),
            Pair::new)
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Void> deleteUser(long id) {
    return mNetworkService.deleteUser(id)
            .flatMap(new Func1<Void, Observable<Void>>() {
                @Override
                public Observable<Void> call(Void avoid) {
                    return mStorageService.deleteUser(id);
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Device> createDevice(Device device) {
    return mNetworkService.createDevice(device)
            .flatMap(new Func1<Device, Observable<Device>>() {
                @Override
                public Observable<Device> call(Device result) {
                    return mStorageService.saveDevice(result);
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Device> updateDevice(Device device) {
    return mNetworkService.updateDevice(device)
            .flatMap(new Func1<Device, Observable<Device>>() {
                @Override
                public Observable<Device> call(Device result) {
                    return mStorageService.saveDevice(result);
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}
 

import com.fernandocejas.frodo.annotation.RxLogObservable; //导入依赖的package包/类
@RxLogObservable
public Observable<Void> deleteDevice(long id) {
    return mNetworkService.deleteDevice(id)
            .flatMap(new Func1<Void, Observable<Void>>() {
                @Override
                public Observable<Void> call(Void avoid) {
                    return mStorageService.deleteDevice(id);
                }
            })
            .compose(Utils.applySchedulers())
            .doOnError(Timber::w);
}