Evoluindo arquiteturas reativas

EVOLUINDO ARQUITETURAS REATIVAS Ubiratan Soares Julho / 2017

O QUE É UMA ARQUITETURA EM MOBILE ?

MVP MVVM VIPER FLUX REDUX CLEAN MVC … MVI

PRINCÍPIOS DE ARQUITETURA Organização Facilidade em se encontrar o que
se precisa Menor impedância para se resolver bugs Menos dor ao escalar em tamanho (codebase e devs) Estilo de projeto uniﬁcado, deﬁnido e defendido pelo time

UMA QUEIXA COMUM NA COMUNIDADE MOBILE ?

TEM PELO MENOS UM UNIT TEST NO APP?

EM MOBILE, ARQUITETURA É CRÍTICA PARA TESTABILIDADE

QUAL ARQUITETURA ESCOLHER ENTÃO ???

NÃO HÁ SILVER BULLETS!

ESTUDO DE CASO MVP / CLEAN

PRESENTATION LAYER DATA LAYER DB REST ETC UI . .
.

public interface ViewDelegate { void displayResults(DataModel model); void networkingError(); void
displayEmptyState(); void displayErrorState(); // More delegation }

public class MainActivity extends AppCompatActivity implements ViewDelegate { Presenter presenter;
// How to resolve this instance ??? @Override protected void onStart() { super.onStart(); presenter.bindView(this); presenter.fetchData(); } @Override public void displayResults(DataModel model) { // Put data into view } @Override public void networkingError() { // Up to you } @Override public void displayEmptyState() { // And this too! } @Override public void displayErrorState() { // Please, do not mess with your user } }

public class Presenter { public void bindView(ViewDelegate delegate) { this.delegate
= delegate; } public void fetchData() { source.fetchData(new DataSource.Callback() { @Override public void onDataLoaded(DataModel model) { delegate.displayResults(model); } @Override public void onError(Throwable t) { if (t instanceof NetworkingError) { delegate.networkingError(); } else if (t instanceof NoDataAvailable) { … } } }); } }

DATASOURCE REST GATEWAY PRESENTER VIEW DELEGATION CALLBACKS PLATAFORM CONTROLLER CALLBACK
UNIT TESTS (Mocked Contract) FUNCTIONAL UI TESTS INTEGRATION TESTS INTEGRATION TESTS (DOUBLES) UNIT TESTS (Mocked Source + Mocked View) DATAMODEL

String description = “Blah” String date = “2010-02-26T19:35:24Z” int step
= 2 String description = “Blah” LocalDateTime dateTime = (JSR310) TrackingStep currentStep = (enum) String description = “Blah” String formattedDate = “26/02/2010” String currentStep = “Concluído” Response Model Domain Model View Model DATA MODEL

PROBLEMAS EM POTENCIAL Qual representação de dados utilizar? Uniﬁcada ou
separada? Onde aplicar parsing? E formatação para a UI? Callbacks aninhados Memory leaks no nível do mecanismo de entrega Etc

BRACE YOURSELVES RX IS COMING

COMO ADICIONAR RX NESSA ARQUITETURA ??

PRESENTATION LAYER DATA LAYER DB REST ETC UI . .
. Callback(T) Callback(T) Callback(T)

SUBSTITUIR CALLBACKS POR SEQUÊNCIAS OBSERVÁVEIS

PRIMEIRA INTERAÇÃO CAMADA DE DADOS REATIVA

REST GATEWAY VIEW DELEGATION VIEW DATA SOURCE Flowable<T> PRESENTER Callback(T)
FlowableSubscriber<T> Disposable

public interface EventsSource { Flowable<Message> fetchWith(MessageToFetchParameters params); Flowable<Message> sendMessage(MessageToSendParameters params);
} ADEUS CALLBACKS !!!

public class MessagesInfrastructure implements EventsSource { @Override public Flowable<Message> fetchWith(MessageToFetch
params) { return restAPI.getMessages(params) .subscribeOn(Schedulers.io()) .map(PayloadMapper::map) .flatMap(Flowable::fromIterable); } @Override public Flowable<Message> sendMessage(MessageToSend params) { SendMessageToBody body = SendMessageToBody.convert(params); return restAPI.sendMessage(body) .subscribeOn(Schedulers.io()) .flatMap(emptyBody -> fetchWith(sameFrom(params))); } } Chained request, easy !!!!

VANTAGENS OBSERVADAS Facilidades via frameworks utilitários para REST / DB
Validação de dados de entrada e tradução de modelos como etapas do pipeline Tratamento de erros, auto retry, exponential backoff no “baixo nível”

PROBLEMAS OBSERVADOS Consumir os dados no nível da apresentação nos
força a rodar comportamentos na thread principal do app (orquestração dos callbacks) Indireção forçada para prover Scheduler via DI, para propósitos de testes Muitas responsabilidades no Presenter

SEGUNDA INTERAÇÃO CAMADA DE APRESENTAÇÃO REATIVA

REST GATEWAY VIEW DELEGATION VIEW DATA SOURCE Flowable<T> PRESENTER FlowableSubscriber<U>
Flowable<U> Disposable

public interface SomeView<T> { Function<Flowable<T>, Disposable> results(); Function<Flowable<Unit>, Disposable> showEmptyState();
Function<Flowable<Unit>, Disposable> hideEmptyState(); Function<Flowable<Unit>, Disposable> showLoading(); Function<Flowable<Unit>, Disposable> hideLoading(); // More delegation }

public static <T> Disposable bind(Flowable<T> flow, Function<Flowable<T>, Disposable> uiFunc) {
return uiFunc.call(flow); } public static <T> Function<Flowable<T>, Disposable> uiFunction(Consumer<T> uiAction) { return uiFunction(uiAction, () -> {}); } public static <T> Function<Flowable<T>, Disposable> uiFunction(Consumer<T> uiAction, Action done) { try { return flowable -> flowable .observeOn(AndroidSchedulers.mainThread()) .subscribe( uiAction, throwable -> Logger.e(throwable.getMessage()), done ); } catch (Exception e) { throw new RuntimeException();} }

public static <T> Disposable bind(Flowable<T> flow, Function<Flowable<T>, Disposable> uiFunc) {
return uiFunc.call(flow); } public static <T> Function<Flowable<T>, Disposable> uiFunction(Consumer<T> uiAction) { return uiFunction(uiAction, () -> {}); } public static <T> Function<Flowable<T>, Disposable> uiFunction(Consumer<T>uiAction, Action done) { try { return flowable -> flowable .observeOn(AndroidSchedulers.mainThread()) .subscribe( uiAction, throwable -> Logger.e(throwable.getMessage()), done ); } catch (Exception e) { throw new RuntimeException();} }

public class MessagingActivity extends BaseActivity implements MessagesStreamView { @Override public
Function<Flowable<String>, Disposable> restoreNotSentMessage() { return uiFunction(message -> { Toast.makeText(this, "Erro ao enviar mensagem", LENGTH_SHORT).show(); messageInput.setText(message); }); } @Override public Function<Flowable<String>, Disposable> enableSomeOption() { return uiFunction(action -> optionView.setVisibility(VISIBLE)); } @Override public Function<Flowable<String>, Disposable> disableSomeOption() { return uiFunction(action -> optionView.setVisibility(GONE)); } @Override public Function<Flowable<String>, Disposable> showEmptyState() { return uiFunction(action -> emptyStateContainer.setVisibility(VISIBLE)); } // More delegate methods

public class MessagingActivity extends BaseActivity implements MessagesStreamView { @Override public
Function<Flowable<String>, Disposable> restoreNotSentMessage() { return uiFunction(message -> { Toast.makeText(this, "Erro ao enviar mensagem", LENGTH_SHORT).show(); messageInput.setText(message); }); } @Override public Function<Flowable<String>, Disposable> enableComplaintOption() { return uiFunction(action -> optionView.setVisibility(VISIBLE)); } @Override public Function<Flowable<String>, Disposable> disableComplaintOption() { return uiFunction(action -> optionView.setVisibility(GONE)); } @Override public Function<Flowable<String>, Disposable> showEmptyState() { return uiFunction(action -> emptyStateContainer.setVisibility(VISIBLE)); } // More delegate methods

public class ReactivePresenter<V> { private final CompositeDisposable disposable = new
CompositeDisposable(); private V view; public void bind(V view) { this.view = view; } public void unbind() { disposable.clear(); this.view = null; } public CompositeDisposable subscriptions() { return disposable; } protected V view() { return view; } protected boolean isBinded() { return view != null; } }

CompositeDisposable(); private V view; public void bind(V view) { this.view = view; } public void unbind() { disposable.dispose(); this.view = null; } public CompositeDisposable subscriptions() { return disposable; } protected V view() { return view; } protected boolean isBinded() { return view != null; } }

public void userRequiredMediation(String userId, String messageText) { MessageToSendParameters parameters =
new MessageToSendParameters.Builder() .userId(userId) // … .messageText(messageText) .build(); executionPipeline(parameters); } private void executionPipeline(MessageToSend parameters) { Flowable<HelpDeskEventViewModel> execution = source.sendMessage(parameters) .doOnSubscribe(this::prepareToLoad) .map(ViewModelMappers::map) .flatMap(Flowable::fromIterable) .doOnCompleted(this::finishLoadingMessages); subscriptions().add(bind(execution, view().onMessagesLoaded())); }

public void userRequiredMediation(String userId, String messageText) { MessageToSendParameters parameters =
new MessageToSendParameters.Builder() .userId(userId) // … .messageText(messageText) .build(); executionPipeline(parameters); } private void executionPipeline(MessageToSend parameters) { Flowable<HelpDeskEventViewModel> execution = source.sendMessage(parameters) .doOnSubscribe(this::prepareToSend) .map(ViewModelMappers::map) .flatMap(Flowable::fromIterable) .doOnCompleted(this::finishSendMessage); subscriptions().add(bind(execution, view().onMessagesLoaded())); }

VANTAGENS OBSERVADAS Presenter não precisa mais da noção de threading
Presenter passar a orquestrar a UI através de um pipeline de execução bem deﬁnido Condições relacionadas aos dados no ciclo de vida do ﬂuxo podem ser disparada a partir do pipeline Tradução de ViewModels é uma etapa do pipeline

PROBLEMAS OBSERVADOS 1) Protocolo View ainda gordo 2) “Repetição” de
código entre Presenters, normalmente relacionada a comportamentos de UI similares que acompanhando o ciclo de vida da sequências - Mostrar empty state se não houver dados - Mostrar loading ao iniciar operação; esconder ao terminar - Etc 3) Testes ruins de serem lidos

@Test public void shouldNotDisplayResults_WhenEmptyData() { presenter.bind(view); // When source has
no data to return when(source.getResults()).thenReturn(Flowable.empty()); // and presenter requires data presenter.fetchResults(); // we should not display any data into View verify(view.resultsDeliveredAction, never()).call(Flowable.just(any()); }

public class MockView implements SomeView { @Mock public Action resultsDeliveredAction;
public MockFAQView() { MockitoAnnotations.initMocks(this); } @Override public Function<Flowable<ViewModel>, Disposable> onResults() { return flowable -> flowable.subscribe(resultsDeliveredAction); } ...

TERCEIRA INTERAÇÃO REACTIVE VIEW SEGREGATION

public interface SomeView<T> { Func1<Flowable<T>, Disposable> results(); Function<Flowable<Unit>, Disposable> showEmptyState();
Function<Flowable<Unit>, Disposable> hideEmptyState(); Function<Flowable<Unit>, Disposable> showLoading(); Function<Flowable<Unit>, Disposable> hideLoading(); Function<Flowable<Unit>, Disposable> networkError(); Function<Flowable<Unit>, Disposable> networkUnavailable(); Function<Flowable<Unit>, Disposable> networkSlow(); }

UI BEHAVIOR VIEW PROTOCOL UI BEHAVIOR UI BEHAVIOR UI BEHAVIOR
. . .

public interface EmptyStateView<T> { Function<Flowable<Unit>, Disposable> showEmptyState(); Function<Flowable<Unit>, Disposable> hideEmptyState();
} public interface LoadingView<T> { Function<Flowable<Unit>, Disposable> showLoading(); Function<Flowable<Unit>, Disposable> hideLoading(); }

public interface SomeView<T> extends LoadingView, EmptyStateView, NetworkingReporterView { Function<Flowable<T>, Disposable>
displayResults(); } public interface NetworkingReporterView<T> { Function<Flowable<Unit>, Disposable> networkError(); Function<Flowable<Unit>, Disposable> networkUnavailable(); Function<Flowable<Unit>, Disposable> networkSlow(); }

- Cada comportamento poderia ter o seu “mini-presenter” associado, e
o Presenter “grande” faria a orquestração dos colaboradores - Melhor estratégia : fazer a composição ser uma etapa do pipeline !!!

f(g(x))

public class LoadingWhenProcessing<T> implements FlowableTransformer<T, T> { private PublishSubject<Unit> show,
hide = PublishSubject.create(); public Dispsoable bind(LoadingView view) { CompositeDisposable composite = new CompositeDisposable(); composite.add(bind(show, view.showLoading())); composite.add(bind(hide, view.hideLoading())); return composite; } @Override public Flowable<T> call(Flowable<T> upstream) { return upstream .doOnSubscribe(this::showLoading) .doOnTerminate(this::hideLoading); } private void hideLoading() { hide.onNext(Unit.instance()); } private void showLoading() { show.onNext(Unit.instance()); } }

public class SomePresenter extends ReactivePresenter<SomeView> { // Hook all behaviors
for view [ ... ] public void executeOperation() { bind(executionPipeline(), view().results()); } private Flowable<Data> executionPipeline() { return source.search() .compose(networkErrorFeedback) .compose(loadingWhenProcessing) .compose(coordinateRefresh) .compose(emptyStateWhenMissingData) .compose(errorWhenProblems) .map(DataViewModelMapper::map); } }

VANTAGENS Cada evento delegado para a UI agora é unit-testable
de uma mais fácil !!! Presenters apenas orquestram a UI (como prega MVP) Transformers são facilmente reutilizáveis

PROBLEMAS ENCONTRADOS (I) 1) Boilerplate para o binding de comportamentos
@Override public void bind(SomeView view) { super.bind(view); subscription().add(loadingWhileProcessing.bind(view)); subscription().add(networkErrorFeedback.bind(view)); subscription().add(coordinateRefresh.bind(view)); subscription().add(emptyStateWhenMissingData.bind(view)); subscription().add(errorStateWhenProblem.bind(view)); }

PROBLEMAS ENCONTRADOS (II) 2) Comportamentos injetados via DI no Presenter;
possível confusão ao fazer pull das dependências 3) Cooperação entre comportamentos, como fazer? 4) Comando para ação na View sinalizado via emissão de item 5) Testes de transformers são mais isolados, mas não necessariamente mais legíveis!

@Test public void shouldTransformView_WhenErrorAtStream() { loadingWhileFetching.bindLoadingContent(view); // When stream will
propagate an error Flowable<String> stream = Flowable.error(new RuntimeCryptoException()); // and we add this transformation to pipeline stream.compose(loadingWhileFetching) .subscribe( s -> {}, throwable -> {}, () -> {} ); // we still should interact with loading actions verify(view.showLoadingAction).call(Flowable.just(any()); verify(view.hideLoadingAction).call(Flowable.just(any()); }

QUARTA INTERAÇÃO SIMPLIFICAR PARA ESCALAR

PRINCÍPIO EM SOFTWARE “Camadas mais internas escondem complexidade das camadas
mais externas”

REMODELANDO AS APIs Queremos manter comportamentos segregados como etapas do
pipeline via transformadores Queremos adicionar mais comportamentos que estão associados à condições dos dados de forma transparente Queremos diminuir a fricção para implementação dessa abordagem em novos ﬂuxos Queremos facilitar escrita e entendimento de testes Queremos fornecer 100% dos objetos via DI (incluindo a própria View)

REPENSANDO VIEW PASSIVA public interface EmptyStateView<T> { Function<Flowable<Unit>, Disposable> showEmptyState();
Function<Flowable<Unit>, Disposable> hideEmptyState(); }

REPENSANDO VIEW PASSIVA public interface EmptyStateView<T> { Function<Flowable<Unit>, Disposable> showEmptyState();
Function<Flowable<Unit>, Disposable> hideEmptyState(); } public interface EmptyStateView { Action showEmptyState(); Action hideEmptyState(); }

IMPL. VIEW PASSIVA (ANTES) @Override public Func1<Observable<Unit>, Subscription> showEmptyState() {
return RxUi.uiFunction(unit -> emptyState.setVisibility(View.VISIBLE)); } @Override public Func1<Observable<Unit>, Subscription> hideEmptyState() { return RxUi.uiFunction(unit -> emptyState.setVisibility(View.GONE)); } @Override public Func1<Observable<Unit>, Subscription> showLoading() { return RxUi.uiFunction(unit -> progress.setVisibility(View.VISIBLE)); } @Override public Func1<Observable<Unit>, Subscription> hideLoading() { return RxUi.uiFunction(unit -> progress.setVisibility(View.GONE)); } // More delegation

IMPL. VIEW PASSIVA (DEPOIS) @Override public Action showLoading() { return
() -> loading.setVisibility(View.VISIBLE); } @Override public Action hideLoading() { return () -> loading.setVisibility(View.GONE); } @Override public Action showEmptyState() { return () -> emptyState.setVisibility(View.VISIBLE); } @Override public Action hideEmptyState() { return () -> emptyState.setVisibility(View.GONE); } // More Delegation

ENTREGA DE DADOS (ANTES) public interface SomeView extends EmptyStateView, LoadingView,
NetworkErrorReporterView { Function<Flowable<ViewModel>, Disposable> onResults(); } // At view implementation @Override public Function<Flowable<ViewModel>, Disposable> onResults() { return RxUi.uiFunction( model -> adapter.add(model), this::displayResults ); }

ENTREGA DE DADOS (DEPOIS) public interface DisplayFactsView extends LoadingView, ErrorStateView,
EmptyStateView { Disposable subscribeInto(Flowable<FactViewModel> flow); } @Override public Disposable subscribeInto(Flowable<FactViewModel> flow) { return flow .observeOn(AndroidSchedulers.mainThread()) .subscribe( model -> addToAdapter(model), throwable -> Logger.e(throwable.getMessage()), () -> displayResults() ); }

public ComplexPresenter( DataSource source, NetworkErrorFeedback networkErrorFeedback, LoadingWhileFetching loadingWhileFetching, CoordinateRefreshWhenLoadingContent coordinateRefresh,
ShowEmptyStateWhenMissingData emptyStateWhenMissingData, ShowErrorState errorState) { this.source = source; this.networkErrorFeedback = networkErrorFeedback; this.loadingWhileFetching = loadingWhileFetching; this.coordinateRefresh = coordinateRefresh; this.emptyStateWhenMissingData = emptyStateWhenMissingData; this.errorState = errorState; } @Override public void bind(ComplexView view) { super.bind(view); subscriptions().add(loadingWhileFetching.bindLoadingContent(view)); subscriptions().add(networkErrorFeedback.bindNetworkingReporter(view)); subscriptions().add(coordinateRefresh.bindRefreshableView(view)); subscriptions().add(emptyStateWhenMissingData.bindEmptyStateView(view)); subscriptions().add(errorState.bindErrorStateView(view)); } ANTES …

public class FactsPresenter { private GetRandomFacts usecase; private DisplayFactsView view;
private BehavioursCoordinator<FactAboutNumber> coordinator; private ViewModelMapper mapper; public FactsPresenter(GetRandomFacts usecase, DisplayFactsView view, BehavioursCoordinator coordinator, ViewModelMapper mapper) { this.usecase = usecase; this.view = view; this.coordinator = coordinator; this.mapper = mapper; } DEPOIS!!!

private BehavioursCoordinator<FactAboutNumber> coordinator; private ViewModelMapper mapper; public FactsPresenter(GetRandomFacts usecase, DisplayFactsView view, BehavioursCoordinator coordinator, ViewModelMapper mapper) { this.usecase = usecase; this.view = view; this.coordinator = coordinator; this.mapper = mapper; }

public class BehavioursCoordinator<T> implements FlowableTransformer<T, T> { private AssignEmptyState<T> dealWithEmptyState;
private AssignErrorState<T> assignErrorState; private LoadingCoordination<T> loadingCoordinator; // More transfomers public BehavioursCoordinator(AssignEmptyState<T> dealWithEmptyState, AssignErrorState<T> assignErrorState, // More transfomers LoadingCoordination<T> loadingCoordinator) { this.dealWithEmptyState = dealWithEmptyState; this.assignErrorState = assignErrorState; this.loadingCoordinator = loadingCoordinator; // More transfomers } @Override public Flowable<T> apply(Flowable<T> upstream) { return upstream .compose(dealWithEmptyState) .compose(assignErrorState) // compose all transformers .compose(loadingCoordinator); } }

public class HideAtStartShowAtError<T> implements FlowableTransformer<T, T> { private Action whenStart;
private Action atError; private ErrorPredicate errorPredicate; private Scheduler targetScheduler; // Constructor @Override public Publisher<T> apply(Flowable<T> upstream) { return upstream .doOnSubscribe(subscription -> hide()) .doOnError(this::evaluateAndShowIfApplicable); } private void evaluateAndShowIfApplicable(Throwable throwable) { if (errorPredicate.evaluate(throwable)) subscribeAndFireAction(atError); } private void hide() { subscribeAndFireAction(whenStart);} private void subscribeAndFireAction(Action toPerform) { Completable.fromAction(toPerform).subscribeOn(targetScheduler).subscribe(); } }

public class AssignEmptyState<T> implements FlowableTransformer<T, T> { EmptyStateView view; Scheduler
uiScheduler; public AssignEmptyState(EmptyStateView view, Scheduler uiScheduler) { this.view = view; this.uiScheduler = uiScheduler; } @Override public Publisher<T> apply(Flowable<T> upstream) { HideAtStartShowAtError<T> delegate = new HideAtStartShowAtError<>( view.hideEmptyState(), view.showEmptyState(), error -> error instanceof ContentNotFoundError, uiScheduler ); return upstream.compose(delegate); } }

public void fetchData() { if (isBinded()) { RxUi.bind(executionPipeline(), view().results()); }
} private Flowable<SomeModel> executionPipeline() { return source.fetch() .compose(networkErrorFeedback) .compose(loadingWhileFetching) .compose(coordinateRefresh) .compose(emptyStateWhenMissingData) .compose(showErroState) .map(ViewModelMapper::map) .flatMap(Flowable::fromIterable); } ANTES …

NOVO PIPELINE public void fetchRandomFacts() { Flowable<FactViewModel> dataFlow = usecase.fetchTrivia()
.compose(coordinator) .map(fact -> mapper.translate(fact)); Disposable toDispose = view.subscribeInto(dataFlow); // TODO : find a better way to handle this Disposable disposable = view.subscribeInto(dataFlow); }

TESTES LIMPOS (I) @Test public void shouldNotAssignError_WhenFlowEmmits() throws Exception {
Flowable.just("A", "B") .compose(assignErrorState) .subscribe(); verify(hide, oneTimeOnly()).run(); verify(show, never()).run(); } @Test public void shouldNotAssignError_WithEmptyFlow() throws Exception { Flowable<String> empty = Flowable.empty(); empty.compose(assignErrorState).subscribe(); verify(hide, oneTimeOnly()).run(); verify(show, never()).run(); }

TESTES LIMPOS (II) @Test public void shouldPresent_NoContentError_IntoView() throws Exception {
Flowable<FactAboutNumber> noContent = Flowable.error(new ContentNotFoundError()); when(usecase.fetchTrivia()).thenReturn(noContent); presenter.fetchRandomFacts(); BehavioursVerifier.with(view) .showLoadingFirstHideLoadingAfter() .shouldShowEmptyState() .shouldNotShowErrorState(); }

TESTES LIMPOS (III) @Test public void shouldPresent_NoContentError_IntoView() throws Exception {
Flowable<FactAboutNumber> noContent = Flowable.error(new ContentNotFoundError()); when(usecase.fetchTrivia()).thenReturn(noContent); presenter.fetchRandomFacts(); BehavioursVerifier.with(view) .showLoadingFirstHideLoadingAfter() .shouldShowEmptyState() .shouldNotShowErrorState(); }

public class BehavioursVerifier { private Object target; // Via factory
method public BehavioursVerifier shouldShowErrorState() throws Exception { checkErrorStateView(); ErrorStateView view = (ErrorStateView) target; verify(view.showErrorState(), oneTimeOnly()).run(); return this; } // For each View and each behavior, check if bind / apply is possible private void checkEmptyStateView() { if (!(target instanceof EmptyStateView)) throw new IllegalArgumentException("Not instance of EmptyStateView"); }

public class BehavioursVerifier { private Object target; public BehavioursVerifier shouldShowErrorState()
throws Exception { checkErrorStateView(); ErrorStateView view = (ErrorStateView) target; verify(view.showErrorState(), oneTimeOnly()).run(); return this; } // For each View and each behavior, check if bind / apply is possible private void checkEmptyStateView() { if (!(target instanceof EmptyStateView)) throw new IllegalArgumentException("Not instance of EmptyStateView"); }

VANTAGENS APIs mais próximas à View agora são muito mais
simples Testes mais simples e legíveis, muito próximos ao MVP sem Rx Menos boilerplate via Coordinator para ações na View que são relacionadas à condições de ﬂuxo Coordinator pode ter quantos comportamentos se deseja independente à qual View for associado

FINAL LAP

Como eliminar as APIs pública e privada do Presenter para
hooks de lifecycle de Activity ou Fragment ???

CompositeDisposable(); private V view; public void bind(V view) { this.view = view; } public void unbind() { disposable.dispose(); this.view = null; } public CompositeDisposable subscriptions() { return disposable; } protected V view() { return view; } protected boolean isBinded() { return view != null; } } ????????

Fazer com que a liberação de Disposable seja responsabilidade de
algum colaborador que conheça o ciclo de vida do mecanismo de entrega

VIEW PROTOCOL VIEW IMPL. PRESENTER FlowableSubscriber<U> Flowable<U> LifecycleStrategist Disposable DisposeStrategy
LifecycleObserver LifecycleOwner Flowable<T> (eg. Activity)

public class DisposeStrategy implements LifecycleObserver { private CompositeDisposable composite =
new CompositeDisposable(); void addDisposable(Disposable toDispose) { composite.add(toDispose); } @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) public void release() { composite.dispose(); } }

public class LifecycleStrategist { private DisposeStrategy strategy; public LifecycleStrategist(LifecycleOwner owner,
DisposeStrategy strategy) { this.strategy = strategy; owner.getLifecycle().addObserver(strategy); } public void applyStrategy(Disposable toDispose) { strategy.addDisposable(toDispose); } }

private BehavioursCoordinator<FactAboutNumber> coordinator; private ViewModelMapper mapper; public FactsPresenter(GetRandomFacts usecase, DisplayFactsView view, BehavioursCoordinator coordinator, LifecycleStrategist strategist, ViewModelMapper mapper) { this.usecase = usecase; this.view = view; this.coordinator = coordinator; this.strategist = strategist; this.mapper = mapper; }

public void fetchRandomFacts() { Flowable<FactViewModel> dataFlow = coordinator .coordinateFlow(usecase.fetchTrivia()) .map(fact
-> mapper.translateFrom(fact)); Disposable toDispose = view.subscribeInto(dataFlow); strategist.applyStrategy(toDispose) }

VANTAGENS OBSERVADAS Presenter não precisa mais de API pública por
motivos de ciclo de vida do mecanismo de entrega Fluxo pode ser construído 100% via DI de forma componetizada

CONCLUSÕES

LIÇÕES APRENDIDAS Escolher um modelo de arquitetura não é uma
tarefa trivial Evoluir um modelo para obter vantagens de um paradigma (FRP) é ainda menos trivial Nem tudo são ﬂores e não tenha medo de errar; adote iterações na evolução da arquitetura junto com seu time Novos problemas sempre aparecerão com as novas soluções

TALK IS CHEAP

https://github.com/ubiratansoares/reactive-architectures-playground Sample usando numbersapi.com 100% RxJava2 + MVP, ilustrando conceitos
vistos aqui Dagger 2.11, Full Android Support APIs Testes de unidade que importam Mais outras coisinhas (WIP)

https://speakerdeck.com/ubiratansoares/evoluindo-arquiteturas-reativas

UBIRATAN SOARES Computer Scientist by ICMC/USP Software Engineer, curious guy
Google Developer Expert for Android Teacher, speaker, etc, etc

OBRIGADO @ubiratanfsoares ubiratansoares.github.io https://br.linkedin.com/in/ubiratanfsoares

Evoluindo arquiteturas reativas

Evoluindo arquiteturas reativas

More Decks by Ubiratan Soares

Other Decks in Programming

Featured

Transcript