How to build a messenger for Android? Rakhimov Andrii Lead Android Engineer at Lalafo [email protected] 

➔ Story ➔ Transport ➔ Properties of transport and protocol ➔ Architecture ➔ MVP & MVI ➔ Learnings Agenda 

Story Story 

Story 

Features ➔ Real time send/delivery 1:1, 1:n ➔ Image/File sending ➔ Delivery status ➔ Typing ➔ Online status ➔ Pagination ➔ Offline pushes ➔ Delete chat ➔ Blacklist user ➔ Different types of chats ➔ Search ➔ Chat with Lalafo ➔ Automate response ➔ ... 

Variety of market solutions 

Telegram Codebase 546 743 LOC 

Transport 

HTTP 

HTTP 

HTTP + Simple - Reopening connection is expensive - Unnecessary requests to server - Slow, not real-time 

HTTP + Firebase Cloud Messaging 

HTTP + Firebase Cloud Messaging + Simple + Works well for a basic need + Close to real-time + Emulation of bidirectional communication - Reopening connection is expensive - Still unnecessary requests to server - Still slow 

Socket solutions 

Socket solutions 

Messaging protocols 

Socket.IO + Reconnects + Bidirectional + Fast + Do not waste connection and resources + Support web - 200+ issues - Not maintained for 2 years 

Acknowledgment 

Duplicate messages 

Duplicate messages 

Time sync and message order 

Time sync and message order ➔ Validate if time is differed widely, and send appropriate time from backend ➔ Store diff on client ➔ Send and show messages accordingly 

Battery concerns 

Battery concerns ProcessLifecycleOwner.get() .getLifecycle() .addObserver(new LifecycleObserver() { @OnLifecycleEvent(Lifecycle.Event.ON_START) public void onEnterForeground() { messengerClient.connect(); } @OnLifecycleEvent(Lifecycle.Event.ON_STOP) public void onEnterBackground() { messengerClient.disconnect(); } }); 

Battery concerns ➔ Don’t keep socket connection open, after user leaves the app ➔ Don’t use foreground Service to keep connection open ➔ Use Firebase Cloud Messaging to notify the app about new messages 

How to design a transport? ➔ Start small ➔ Determine your business needs ◆ Speed ◆ Security ◆ Features ◆ Web support ➔ Make it flexible ➔ Remember about battery 

Architecture 

Architecture ➔ Extensible ➔ Maintainable ➔ Reusable ➔ Composable ➔ Testable 

Clean Architecture Dependency rule 

Architecture 

Why eventBus? 

MVP & MVI 

MVP & MVI 

MVP & MVI 

MVP & MVI 

MVP issues ➔ Many events can trigger same UI changes as result broken UI ➔ Scales badly on huge and complex screens, presenters polluted with logic ➔ Testability 

MVP & MVI 

MVVM & MVI 

MVP & MVI 

/** * Input Actions */ sealed class Action { object LoadNextPageAction : Action() data class ErrorLoadingPageAction(val error: Throwable, val page: Int) : Action() data class PageLoadedAction(val itemsLoaded: List, val page: Int) : Action() data class StartLoadingNextPage(val page: Int) : Action() } StateMachine Actions 

StateMachine States sealed class State { object LoadingFirstPageState : State() data class ErrorLoadingFirstPageState(val errorMessage: String) : State() data class ShowContentState(val items: List, val page: Int) : State() } 

StateMachine Setup class PaginationStateMachine @Inject constructor(private val api: GithubApiFacade) { val input: Relay = PublishRelay.create() val state: Observable = input .reduxStore( initialState = State.LoadingFirstPageState, sideEffects = listOf( ::loadFirstPageSideEffect, ::loadNextPageSideEffect, ::showAndHideLoadingErrorSideEffect ), reducer = ::reducer ) 

StateMachine Side Effect /** * Load the first Page */ private fun loadFirstPageSideEffect(actions: Observable, state: StateAccessor): Observable { return actions.ofType(Action.LoadFirstPageAction::class.java) .filter { state() !is ContainsItems } // If first page has already been loaded, do nothing .switchMap { val state = state() val nextPage = (if (state is ContainsItems) state.page else 0) + 1 api.loadNextPage(nextPage) .subscribeOn(Schedulers.io()) .toObservable() .map { result -> PageLoadedAction(itemsLoaded = result.items, page = nextPage) } .onErrorReturn { error -> ErrorLoadingPageAction(error, nextPage) } .startWith(StartLoadingNextPage(nextPage)) } } 

StateMachine Reducer /** * The state reducer. * Takes Actions and the current state to calculate the new state. */ private fun reducer(state: State, action: Action): State { return when (action) { is StartLoadingNextPage -> State.LoadingFirstPageState is PageLoadedAction -> State.ShowContentState(items = action.items, page = action.page) is ErrorLoadingPageAction -> State.ErrorLoadingFirstPageState(action.error.localizedMessage) } } 

Displaying state open fun render(state: PaginationStateMachine.State) = when (state) { PaginationStateMachine.State.LoadingFirstPageState -> { recyclerView.gone() loading.visible() error.gone() } is PaginationStateMachine.State.ShowContentState -> { showRecyclerView(items = state.items, showLoadingNext = false) } is PaginationStateMachine.State.ErrorLoadingFirstPageState -> { recyclerView.gone() loading.gone() error.visible() snackBar?.dismiss() } } 

DistinctUntilChanged val state: Observable = input .reduxStore( initialState = State.LoadingFirstPageState, sideEffects = listOf( ::loadFirstPageSideEffect, ::loadNextPageSideEffect, ::showAndHideLoadingErrorSideEffect ), reducer = ::reducer ) .distinctUntilChanged() 

Testing @Test fun `Empty upstream just emits initial state and completes`() { val upstream: Observable = Observable.empty() upstream.reduxStore( "InitialState", sideEffects = emptyList() ) { state, action -> state } .test() .assertNoErrors() .assertValues("InitialState") .assertComplete() } 

Pagination ➔ Use one source of truth for paging DB, api, local storage, etc.. ➔ Use DiffUtil ➔ Use distinctUntilChanged or similar 

Architecture ➔ Extensiblish ➔ Maintainable ➔ Reusable ➔ Testable ➔ Composablish 

Learnings ➔ Fair estimates 

Fair estimates 

Learnings ➔ Fair estimates ➔ Use appropriate technology for the task 

No content

Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility 

Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility ➔ Start small and validate hypothesis early 

Cost of change 

Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility ➔ Start small and validate hypothesis early 

Thank you! We are hiring! Rakhimov Andrii Lead Android Engineer at Lalafo [email protected] https://github.com/ar-g