How to build a messenger on Android?

Transcript

1. How to build a messenger for Android? Rakhimov Andrii Lead Android Engineer at Lalafo andrii.rakhimov@gmail.com
2. ➔ Story ➔ Transport ➔ Properties of transport and protocol ➔ Architecture ➔ MVP & MVI ➔ Learnings Agenda
3. Story Story
4. Story
5. 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 ➔ ...
6. Variety of market solutions
7. Telegram Codebase 546 743 LOC
8. Transport
9. HTTP
10. HTTP
11. HTTP + Simple - Reopening connection is expensive - Unnecessary requests to server - Slow, not real-time
12. HTTP + Firebase Cloud Messaging
13. 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
14. Socket solutions
15. Socket solutions
16. Messaging protocols
17. Socket.IO + Reconnects + Bidirectional + Fast + Do not waste connection and resources + Support web - 200+ issues - Not maintained for 2 years
18. Acknowledgment
19. Duplicate messages
20. Duplicate messages
21. Time sync and message order
22. 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
23. Battery concerns
24. 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(); } });
25. 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
26. How to design a transport? ➔ Start small ➔ Determine your business needs ◆ Speed ◆ Security ◆ Features ◆ Web support ➔ Make it flexible ➔ Remember about battery
27. Architecture
28. Architecture ➔ Extensible ➔ Maintainable ➔ Reusable ➔ Composable ➔ Testable
29. Clean Architecture Dependency rule
30. Architecture
31. Why eventBus?
32. MVP & MVI
33. MVP & MVI
34. MVP & MVI
35. MVP & MVI
36. 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
37. MVP & MVI
38. MVVM & MVI
39. MVP & MVI
40. /** * Input Actions */ sealed class Action { object LoadNextPageAction : Action() data class ErrorLoadingPageAction(val error: Throwable, val page: Int) : Action() data class PageLoadedAction(val itemsLoaded: List<GithubRepository>, val page: Int) : Action() data class StartLoadingNextPage(val page: Int) : Action() } StateMachine Actions
41. StateMachine States sealed class State { object LoadingFirstPageState : State() data class ErrorLoadingFirstPageState(val errorMessage: String) : State() data class ShowContentState(val items: List<GithubRepository>, val page: Int) : State() }
42. StateMachine Setup class PaginationStateMachine @Inject constructor(private val api: GithubApiFacade) { val input: Relay<Action> = PublishRelay.create() val state: Observable<State> = input .reduxStore( initialState = State.LoadingFirstPageState, sideEffects = listOf( ::loadFirstPageSideEffect, ::loadNextPageSideEffect, ::showAndHideLoadingErrorSideEffect ), reducer = ::reducer )
43. StateMachine Side Effect /** * Load the first Page */ private fun loadFirstPageSideEffect(actions: Observable<Action>, state: StateAccessor<State>): Observable<Action> { 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<Action> { result -> PageLoadedAction(itemsLoaded = result.items, page = nextPage) } .onErrorReturn { error -> ErrorLoadingPageAction(error, nextPage) } .startWith(StartLoadingNextPage(nextPage)) } }
44. 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) } }
45. 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() } }
46. DistinctUntilChanged val state: Observable<State> = input .reduxStore( initialState = State.LoadingFirstPageState, sideEffects = listOf( ::loadFirstPageSideEffect, ::loadNextPageSideEffect, ::showAndHideLoadingErrorSideEffect ), reducer = ::reducer ) .distinctUntilChanged()
47. Testing @Test fun `Empty upstream just emits initial state and completes`() { val upstream: Observable<String> = Observable.empty() upstream.reduxStore( "InitialState", sideEffects = emptyList() ) { state, action -> state } .test() .assertNoErrors() .assertValues("InitialState") .assertComplete() }
48. Pagination ➔ Use one source of truth for paging DB, api, local storage, etc.. ➔ Use DiffUtil ➔ Use distinctUntilChanged or similar
49. Architecture ➔ Extensiblish ➔ Maintainable ➔ Reusable ➔ Testable ➔ Composablish
50. Learnings ➔ Fair estimates
51. Fair estimates
52. Learnings ➔ Fair estimates ➔ Use appropriate technology for the task
54. Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility
55. Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility ➔ Start small and validate hypothesis early
56. Cost of change
57. Learnings ➔ Fair estimates ➔ Use appropriate technology for the task ➔ Design for flexibility ➔ Start small and validate hypothesis early
58. Thank you! We are hiring! Rakhimov Andrii Lead Android Engineer at Lalafo andrii.rakhimov@gmail.com https://github.com/ar-g