10 ways to improve your Android app performance

1. 10 ways to improve your app's performance Boris Farber Developer Advocate Google
2. Data Intensive apps • Long launch time • Janky scrolling • Unresponsive app
3. IF YOU HAVE A SMALL APP FORGET THESE SLIDES
4. 1 - Activity leaks
5. Activity
6. Why memory leaks are dangerous • Holding references to unused Activity • Activity holds its layout ==> holds all views
7. Listeners leak public class LeakActivity extends Activity { // ... @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); NastyManager.getInstance().addListener(this); // ...
8. Listener's leak + fix @Override public void onDestroy() { super.onDestroy(); NastyManager.getInstance().removeListener(this); } remove listener
9. Static References • Activities/fragments etc - they have a life cycle • Activity will not be GC-ed • Static references ◦ become dangling "pointers" ◦ m_staticActivity = staticFragment.getActivity()
10. Activity
11. 2 - Activity leaks
12. Outer class (Activity) Inner class (Handler)
13. This is a leak public class MainActivity extends Activity { // ... Handler handler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // ... handler = new Handler() { @Override public void handleMessage(Message msg) { } }; // ...
14. What happens if ... handler.postDelayed(...)
15. This is a leak + fix private static class MyHandler extends Handler { private final WeakReference<MainActivity> mActivity; // ... public MyHandler(MainActivity activity) { mActivity = new WeakReference<MainActivity>(activity); // ... } @Override public void handleMessage(Message msg) { } // ... }
16. Outer class (Activity) Inner class (Handler)
17. Prefer static to non static inner classes • Non static Handler --> Activity leak • Both classes have a different lifetime
18. What you can do Activity Leaks • Remove away static references • Use event bus • Unregister listeners • Prefer static inner classes to non static ones
19. What you can do Activity Leaks • Do code reviews • Understand your app structure • Use tools (MAT ...) • Print logs on callbacks
20. 3 - Use UI thread only for UI
21. Not on UI thread • Images (caching, loading) • Networking • JSON • Database access
22. Not on UI thread • Images (caching, loading) • Networking • JSON • Database access Use Loaders Use libraries
23. UI thread Looper.myLooper() == Looper.getMainLooper()
24. 4 - Use libraries
25. Images • Glide • Picasso • Fresco • ... Different design tradeoffs, especially around large images count
26. Memory • Bitmaps are tricky ◦ Large size ◦ Fragmented heap ◦ ... • LRUCache - part of the support library
27. Networking • Tricky APIs • Many java.net API calls are blocking ◦ Streams ◦ Equals of URL class result in DNS call
28. Networking/Async Http • OkHttp - part of Android (from 4.4) • Volley • Retrofit - rest calls
29. 5 - Large JSONs
30. Large JSON • Parsing has a performance effect • Converted to class with getters and setters
31. JSON • Small JSONs - GSON is the best • Large JSONs - Jackson, ig-json-parser
32. What you can do Scrolling • Keep UI thread only for UI • Understand concurrency APIs (next bullet) • Use libraries (memory, caching, json ...) • Use loaders
33. 6 - Concurrency APIs
34. Service • Service methods run on UI thread ! • Consider ◦ IntentService ◦ AsyncTask ◦ Executors ◦ HandlerThreads, Handlers and Loopers - Appendix
35. IntentService • Single threaded • Simple/One job in a time • No job system (keep track for jobs) • No way to stop it
36. AsyncTask • Don't care about result outside of UI • Activity lifecycles - can cause a memory leak (rotation) • Changes rapidly (grab latest and add to your project)
37. Executor Framework • Thread pool • Callbacks • Futures • MapReduce tasks
38. What you can do Concurrency API • Understand the APIs and tradeoffs • Refactor
39. 7 - System abuse
40. System Abuse • Don't call private APIs by reflection • Don't call private native methods (NDK/C level) • Don't use Runtime.exec • "adb shell am" to communicate with other process is not something we want to support
41. 8 - Deprecation
42. Deprecation • API will be removed • Your app will not work • No way to update APIs and tools
43. Deprecation • There is a compelling reason to move ◦ Security ◦ Correctness ◦ Performance
44. What you can do around deprecation • Know and use APIs • Refactor your dependencies
45. Don't use Apache Http Connection • Removed at M (still available as dependency) • Use HttpURLConnection ◦ Simple API ◦ Small size ◦ Transparent compression ◦ Response caching
46. What you can do Deprecation • Don't abuse the system • Update your dependencies and tools
47. 9 - Bring your own gloves
48. Bring your own gloves • Various versions, devices, OEMs • APIs and libraries shipped with platform might behave differently • Async task ...
49. Bring your own gloves • Consider bundling your own version • Check dex limit • Check code bloat
50. Security • Own wrapped library (SSL/crypto etc') • Rooted devices • Your own sensitive data/protocols
51. 10 - Architecture
52. Understand app components life cycle • Activities • Fragments • Tasks • Flags • Add logs on callbacks
53. Work with framework not against ... • Framework components have a purpose ◦ Specific semantics ◦ Used when those semantics are desired • Don't over engineer • Keep simple
54. Pick 3rd party lib checklist • Solves your problem • Plays nicely with your current dependencies • Dex method count • Dependencies • Maintenance • Runtime permissions
55. Design your app for • Sleeping most of the time • Responsive when "awaken"
56. What you can do Architecture • Consistent • Get people on board quickly • Have someone experienced • Pick your dependencies wisely
57. Boris Farber www.api-solutions.com @BorisFarber
58. Appendix Loopers/Handlers
59. HandlerThread • A thread with a message box • Saves a lot of boilerplate code • Uses Looper
60. Loopers and Handlers • Looper ◦ Synchronized message queue to process messages from handlers ◦ Takes the next task, executes it, then takes the next one and so on ◦ One looper per thread • Handler ◦ Set of methods to post messages
61. Inside Looper (Android src) private Looper(boolean quitAllowed) { // ... mThread = Thread.currentThread(); } /** * Run the message queue in this thread. Be sure to call * {@link #quit()} to end the loop. */ public static void loop() { final Looper me = myLooper(); // ... for (; ; ) { // ... } infinite loop