Evolution of Android Background tools

Transcript

2. Evolution of tools of background work in Android 2
3. Disclaimer Everything told here is a product of personal professional experience and not anything more. 3
4. About me 4
5. About me — Vladimir Ivanov - Lead Software Engineer in EPAM 4
6. About me — Vladimir Ivanov - Lead Software Engineer in EPAM — Android apps: > 15 published, > 7 years 4
7. About me — Vladimir Ivanov - Lead Software Engineer in EPAM — Android apps: > 15 published, > 7 years — Wide expertise in Mobile 4
8. Agenda 5
9. Agenda — AsyncTasks 5
10. Agenda — AsyncTasks — Loaders 5
11. Agenda — AsyncTasks — Loaders — Executors&Event bus 5
12. Agenda — AsyncTasks — Loaders — Executors&Event bus — RxJava 5
13. Agenda — AsyncTasks — Loaders — Executors&Event bus — RxJava — Coroutines 5
14. Out-of-scope 6
15. Out-of-scope — Services 6
16. Out-of-scope — Services — Sync Adapters 6
17. What it is your first Android OS you wrote code for? 7
18. Why do we need background? 8
19. Why do we need background? — 60 FPS 8
20. Why do we need background? — 60 FPS — UI updates only on the main thread 8
21. Android 1.6: Async tasks 9
22. public class LoadWeatherForecastTask extends AsyncTask<String, Integer, Forecast> { public Forecast doInBackground(String... params) { HttpClient client = new HttpClient(); HttpGet request = new HttpRequest(params[0]); HttpResponse response = client.execute(request); return parse(response); } } 10
23. Which thread the doInBackground() is called on? 11
24. Which thread the doInBackground() is called on? Fixed-sized threadpool executor of size 1 12
25. public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); 13
26. public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); ... private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; 14
27. The result should be posted on the UI Thread 15
28. public class LoadWeatherForecastTask extends AsyncTask<String, Integer, Forecast> { public void onPostExecute(Forecast forecast) { mTemperatureView.setText(forecast.getTemp()); } } 16
29. Just Handler 17
30. Minuses 18
31. Minuses — Boilerplate 18
32. Minuses — Boilerplate — Lifecycle not-aware 18
33. Minuses — Boilerplate — Lifecycle not-aware — No result reusage across configuration changes 18
34. Minuses — Boilerplate — Lifecycle not-aware — No result reusage across configuration changes — Easy way to introduce memory leaks 18
35. Android 3.0: Loaders 19
36. inner class WeatherForecastLoaderCallbacks : LoaderManager.LoaderCallbacks<WeatherForecast> { 20
37. inner class WeatherForecastLoaderCallbacks : LoaderManager.LoaderCallbacks<WeatherForecast> { override fun onCreateLoader(id: Int, args: Bundle?): Loader<WeatherForecast> { return WeatherForecastLoader(applicationContext) } } 21
38. inner class WeatherForecastLoaderCallbacks : LoaderManager.LoaderCallbacks<WeatherForecast> { override fun onCreateLoader(id: Int, args: Bundle?): Loader<WeatherForecast> { return WeatherForecastLoader(applicationContext) } override fun onLoadFinished(loader: Loader<WeatherForecast>?, data: WeatherForecast) { temperatureTextView.text = data.temp.toString(); } } 22
39. class WeatherForecastLoader(context: Context) : AsyncTaskLoader<WeatherForecast>(context) { override fun loadInBackground(): WeatherForecast { try { Thread.sleep(5000) } catch (e: InterruptedException) { return WeatherForecast("", 0F, "") } return WeatherForecast("Saint-Petersburg", 20F, "Sunny") } } 23
40. override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) ... val weatherForecastLoader = WeatherForecastLoaderCallbacks() loaderManager .initLoader(forecastLoaderId, Bundle(), weatherForecastLoader) } 24
41. How does the loader gets reused? 25
43. How does the loader gets reused? 27
44. How does the loader gets reused? — LoaderManager saves all loaders internally 27
45. How does the loader gets reused? — LoaderManager saves all loaders internally — Activity saves all LoaderManagers inside NonConfigurationInstances 27
46. How does the loader gets reused? — LoaderManager saves all loaders internally — Activity saves all LoaderManagers inside NonConfigurationInstances — On activity recreation NonConfigurationInstances got passed to a new activity 27
47. Minuses 28
48. Minuses — Still a lot of boilerplate 28
49. Minuses — Still a lot of boilerplate — Complex interfaces and abstract classes 28
50. Minuses — Still a lot of boilerplate — Complex interfaces and abstract classes — Loaders are Android API - you can’t create libs in pure Java 28
51. Thread pool executors FTW! 29
52. public class Background { private val mService = ScheduledThreadPoolExecutor(5) fun execute(runnable: Runnable): Future<*> { return mService.submit(runnable) } fun <T> submit(runnable: Callable<T>): Future<T> { return mService.submit(runnable) } } 30
53. public class Background { … private lateinit var mUiHandler: Handler public fun postOnUiThread(runnable: Runnable) { mUiHandler.post(runnable) } } 31
54. But how will out UI know it should be changed? 32
55. Event bus! 33
57. Event bus implementations 35
58. Event bus implementations — Google guava 35
59. Event bus implementations — Google guava — Otto 35
60. Event bus implementations — Google guava — Otto — Greenbot eventbus 35
61. public class Background { private lateinit val mEventBus: Bus fun postEvent(event: Any) { mEventBus.post(event) } } 36
62. mBackground.execute(Runnable { try { initDatabaseInternal() mBackground.post(DatabaseLoadedEvent()) } catch (e: Exception) { Log.e("Failed to init db", e) } 37
63. public class SplashActivity : Activity() { @Subscribe fun on(event: DatabaseLoadedEvent) { progressBar.setVisibility(View.GONE) showMainActivity() } override fun onStart() { super.onStart() eventBus.register(this) } override fun onStop() { eventBus.unregister(this) super.onStop() } } 38
64. What is the problem here? 39
65. UI is modified from the background thread! 40
66. public class Background { fun postEventOnUiThread(event: Any) { mUiHandler.post(Runnable { mEventBus.post(event) }) } } 41
67. Minuses 42
68. Minuses — The posting code knows which thread is needed on the listeners code 42
69. Minuses — The posting code knows which thread is needed on the listeners code — The actual projects begin to be unmaintanable with EventBus 42
70. Next step: RxJava! 43
71. interface ApiClientRx { fun login(auth: Authorization) : Single<GithubUser> fun getRepositories (reposUrl: String, auth: Authorization) : Single<List<GithubRepository>> } 44
72. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 45
73. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 46
74. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 47
75. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 48
76. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 49
77. Threading? 50
78. private fun attemptLoginRx() { showProgress(true) apiClient.login(auth) .flatMap { user -> apiClient.getRepositories(user.repos_url, auth) } .map { list -> list.map { it.full_name } } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .doFinally { showProgress(false) } .subscribe( { list -> showRepositories(this@LoginActivity, list) }, { error -> Log.e("TAG", "Failed to show repos", error) } ) } 51
79. Pluses 52
80. Pluses — Standard de-facto, 65% of new projects will use RxJava 52
81. Pluses — Standard de-facto, 65% of new projects will use RxJava — Powerful API, lots of operators 52
82. Pluses — Standard de-facto, 65% of new projects will use RxJava — Powerful API, lots of operators — Opensource and community driven library 52
83. Pluses — Standard de-facto, 65% of new projects will use RxJava — Powerful API, lots of operators — Opensource and community driven library — Adapters for popular libraries like Retrofit 52
84. Pluses — Standard de-facto, 65% of new projects will use RxJava — Powerful API, lots of operators — Opensource and community driven library — Adapters for popular libraries like Retrofit — Relatively easy to provide unit-tests 52
85. Minuses 53
86. Minuses — Touch learning curve 53
87. Minuses — Touch learning curve — Operators to learn 53
88. Minuses — Touch learning curve — Operators to learn — Callback style 53
89. Minuses — Touch learning curve — Operators to learn — Callback style — Memory overhead 53
90. Minuses — Touch learning curve — Operators to learn — Callback style — Memory overhead — Unrelated stacktraces 53
91. What’s next? 54
92. What’s next? Kotlin coroutines! 55
93. private fun attemptLogin() { launch(UI) { val auth = BasicAuthorization(login, pass) try { showProgress(true) val userInfo = login(auth).await() val repoUrl = userInfo.repos_url val list = getRepositories(repoUrl, auth).await() showRepositories( this@LoginActivity, list.map { it -> it.full_name } ) } catch (e: RuntimeException) { Toast.makeText(this@LoginActivity, e.message, LENGTH_LONG).show() } finally { showProgress(false) } } } 56
94. private fun attemptLogin() { … launch(UI) { val auth = BasicAuthorization(login, pass) try { showProgress(true) val userInfo = login(auth).await() val repoUrl = userInfo.repos_url val list = getRepositories(repoUrl, auth).await() showRepositories(this@LoginActivity, list.map { it -> it.full_name }) } catch (e: RuntimeException) { Toast.makeText(this@LoginActivity, e.message, LENGTH_LONG).show() } finally { showProgress(false) } } } 57
95. Suspension 58
97. Pluses 60
98. Pluses — Non-blocking approach 60
99. Pluses — Non-blocking approach — Async code, sync styled 60
100. Pluses — Non-blocking approach — Async code, sync styled — Language tools instead of operators 60
101. Pluses — Non-blocking approach — Async code, sync styled — Language tools instead of operators — Learning curve is almost straight-line 60
102. Pluses — Non-blocking approach — Async code, sync styled — Language tools instead of operators — Learning curve is almost straight-line — Unit-tests are easy 60
103. Minuses 61
104. Minuses — Fresh thing, status: experimental 61
105. Minuses — Fresh thing, status: experimental — Library adapters are not ready(retrofit?) 61
106. Minuses — Fresh thing, status: experimental — Library adapters are not ready(retrofit?) — Not a replacement for Rx 61
107. Summary 62
108. Summary — Android went long path 62
109. Summary — Android went long path — The modern tools are RxJava and Coroutines 62
110. Summary — Android went long path — The modern tools are RxJava and Coroutines — But legacy is still there, hence the talk 62
111. Contacts 63
112. Contacts — https://github.com/Kotlin/kotlinx.coroutines ! 63
113. Contacts — https://github.com/Kotlin/kotlinx.coroutines ! — https://twitter.com/vvsevolodovich " 63
114. Contacts — https://github.com/Kotlin/kotlinx.coroutines ! — https://twitter.com/vvsevolodovich " — https://medium.com/@dzigorium # 63