RxJava si iscrive nuovamente all'evento dopo il ripristino dell'attività

Question

Sto ancora cercando RxJava e lo utilizzo per fare alcune cose di networking con Retrofit 2. Lo sto provando da un paio di giorni e così il codice sembra più leggibile ora ma si è imbattuto in un problema che non riesco a capire un modo per aggirare.

Sto tentando di eseguire un accesso (che restituisce un token API) e quindi utilizzare questo token per recuperare alcuni dati iniziali tutti nella stessa catena in modo che l'output della catena sia il token + i dati. Per fare questo io chiamo il mio servizio API con un

apiClient 
    .login() 
    .subscribeOn(Schedulers.io()) 
    .observeOn(AndroidSchedulers.mainThread()) 
    .flatMap(token -> getData(token)) 
    .subscribe(new Subscrber<Bundle>() {...}); 

Questo sembrava a posto, ma ho anche voluto mostrare una barra di avanzamento durante l'avvio e l'arresto della catena. Così ho aggiunto un .doOnSubscribe() e un .doOnUnsubscribe() anche a questo. Tuttavia ho notato che dopo il cambiamento di orientamento il frammento che stavo cercando di nascondere la barra di avanzamento è sempre nullo.

Così ho cercato e mi sono imbattuto nel lib RxLifecycle che sembrava come se potesse essere d'aiuto e io ora .cache() e annullare l'iscrizione dalla catena di eventi. Ma non riesco a capire come iscriversi allo stesso evento di nuovo in onCreate() dopo questo? Penso che mi manchi qualcosa di abbastanza semplice e apprezzerei qualsiasi aiuto con questo.

Answer 1

È necessario fare in modo che si sottoscrive il stesso Osservabile esempio che viene restituito dal .cache(). In genere si memorizza questa istanza da qualche parte in un Singleton (come la classe Application), un frammento conservato o un servizio Android.

Answer 2

Non è necessario utilizzare alcun modello di architettura per ottenerlo. Sebbene qualsiasi MVP/MVC sia bello per questioni di separazione, test, ecc., Rendendo il tuo Controller/Presentatore/DAO un singleton a livello di applicazione, che mantiene la memoria durante tutta la vita dell'applicazione, non è esattamente una buona idea.

Ecco un progetto di esempio utilizzando esempio frammento conservato e RxJava - https://github.com/krpiotrek/RetainFragmentSample

L'idea principale non è quella di utilizzare Frammento con setRetainInstance (vero) chiamati, che lo protegge dalla distruzione sul cambiamento di orientamento, e memorizzare la vostra Osservabile in là. Ecco come gestire che in Attività/Frammento onCreate

protected void onCreate(Bundle savedInstanceState) { 
    if (savedInstanceState == null) { 
     // first run, create observable 
     mInfoObservable = createInfoObservable(); 
     // set Observable in retained fragment 
     RetainFragmentHelper.setObject(this, getSupportFragmentManager(), mInfoObservable); 
    } else { 
     // following runs, get observable from retained fragment 
     mInfoObservable = RetainFragmentHelper.getObjectOrNull(this, getSupportFragmentManager()); 
    } 

    // subscribe 
    mInfoObservable.subscribe(...); 
} 

Tenete a mente che il vostro Observable deve memorizzare nella cache ultimo valore, un modo è quello uso della cache() dell'operatore.