Quelle est la meilleure approche de remplacement de AsyncTaskLoader par RxJava2?

Question

Je suis super junior dans RxJava et j'ai besoin d'aide pour trouver une meilleure approche si j'ai choisi une mauvaise approche ou s'il y a une meilleure façon de faire.

Je travaille sur un ancien code Loader et je veux le remplacer par RxJava. Je suit Dans mon code d'origine:

public class CurrentBookingLoaderManager extends AsyncTaskLoader<Booking> { 
    ... 

    @Override 
    public Booking loadInBackground() { 
     try { 
      return createPendingBookingObserver().blockingGet(); // Gets last Booking from back-end 
     } catch (Exception e) { 
      Logger.logCaughtException(e); 
      return loadPendingBookingFromDB(); 
     } 
    } 

    private Single<Booking> createPendingBookingObserver() {...} 

    private Booking loadPendingBookingFromDB() {...} 
} 

Alors, Ma classe Présentateur recherche dernier objet de réservation afin de l'utilisateur directement à l'écran suivant (en fonction du statut de la réservation).

final class Presenter { 
    void findLatestBooking() { 
     CurrentBookingLoaderManager.newInstance(mContext) 
       .getPendingBooking(mActivity, new CurrentBookingLoaderManager.OnPendingBooking() { 
        @Override 
        public void found(Booking booking) { 
         ... 
        } 
       }); 
    } 
} 

Retour à CurrentBookingLoaderManager, je crée une interface et quelques méthodes pour factoriser la fonctionnalité de loadInBackground() de manière Rx.

public interface OnPendingBooking { 
     void found(Booking booking); 
    } 

    public void getPendingBooking(final MyActivity activity, final OnPendingBooking callback) { 
     CurrentBookingLoaderManager.newInstance(activity) 
       .createPendingBookingObserver() 
       .compose(activity.<Booking>asyncCallWithinLifecycle()) 
       .subscribeOn(Schedulers.newThread()) 
       .observeOn(AndroidSchedulers.mainThread()) 
       .subscribe(new Consumer<Booking>() { 
        @Override 
        public void accept(Booking booking) throws Exception { 
         callback.found(booking); 
        } 
       }, new Consumer<Throwable>() { 
        @Override 
        public void accept(Throwable throwable) throws Exception { 
         loadPendingBookingFromDB(activity, callback); 
        } 
       }); 
    } 

    private void loadPendingBookingFromDB(final MyActivity activity, final OnPendingBooking callback) { 
     Single.fromCallable(new Callable<Booking>() { 
      @Override 
      public Booking call() throws Exception { 
       return loadPendingBookingFromDB(); 
      } 
     }) 
       .compose(activity.<Booking>asyncCallWithinLifecycle()) 
       .subscribeOn(Schedulers.newThread()) 
       .observeOn(AndroidSchedulers.mainThread()) 
       .subscribe(new Consumer<Booking>() { 
        @Override 
        public void accept(Booking booking) throws Exception { 
         callback.found(booking); 
        } 
       }, new Consumer<Throwable>() { 
        @Override 
        public void accept(Throwable throwable) throws Exception { 
         callback.found(null); 
        } 
       }); 
    } 

Ce qui me fait sentir ce n'est pas la bonne approche est d'avoir beaucoup de lignes en utilisant RxJava tandis que Rx réduit normalement nombre de lignes de code. Alors, s'il vous plaît, donnez-moi un point si vous pensez qu'il y a une meilleure façon de le faire.

Ce code fonctionne très bien selon mes tests. Merci

Answer 1

1. RetroLambda
2. SqlBrite au lieu de AsyncTaskLoader
3. Si possible Realm au lieu de SQLite.
4. subscribeOn(Schedulers.newThread()) ->subscribeOn(Schedulers.io()) (pas besoin de créer un nouveau fil à chaque fois)
5. Et

Observable .subscribeOn(Schedulers.newThread()) .observeOn(AndroidSchedulers.mainThread())

peut être remplacé par

public class RxUtil { 

    public static <T> Observable.Transformer<T, T> applySchedulers() { 
     return observable -> observable.subscribeOn(Schedulers.io()) 
       .observeOn(AndroidSchedulers.mainThread()); 
    } 
} 

et

Observable 
    .compose(RxUtil::applySchedulers)