Improve Android App Performance

According to Droidcon NYC 2015 : 10 ways to improve your Android app performance
Boris Farber | YouTube | SlideShare

Attention: If you have a small app forget this article.

1.Memory Leaks

• a.Listener’s Leak

public class LeakActivity extends Activity{
//...
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    NastyManager.getInstance().addListener(this);
  }
}

• a.Fix Listener’s Leak

@Override
public void OnDestroy(){
  super.onDestroy();
  NastyManager.getInstance().removeListener(this);
}

• b.Activity Leaks

public class MainActivity extends Activity {
  //...
  Handler handler;
  @Override
  protected void onCreate(Bundle savedInstacneState) {
    super.onCreate(savedInstanceState);
    //...
    handler = new Handler() {
      @Override
      public void handleMessage(Message msg){
        //...
      }
    }
    //What happens if handler.postDelayed(...)
  }
}

• b.Fix Activity’s Leaks

private static class FixedHandler extends Handler {
  private final WeakReference<MainActivity> mActivity;
  //...
  public FixedHandler(MainActivity activity) {
    mActivity = new WeakReference<MainActivity>(activity);
    //...
  }
  @Override
  public void handlerMessage(Message msg) {}
  //...
}

• c 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();

• c.Fix Prefer static to non static inner classes

  • Non static Handler –> Activity leak
  • Both classes have a different lifetime

• d.what you can do Activity Leaks -1

  • Remove away static references
  • Use event bus
  • Unregister listeners
  • Prefer static inner classes to non static ones
• d.what you can do Activity Leaks -2
  
  • Do code reviews
  • Understand your app structure
  • Use tools
  • Print logs on callbacks

2.Use UI Thread only for UI

Symptons

• Scrolling

Not on UI thread

• Images
• Networking
• JSON (next bullet) (Use libraries)
• Database access (Use Loaders)

3.Use libraries

Use libraries

• Already solve the problem
• Requires specialization (easy to make mistake)
  
  • Threading
  • Memory
  • Networking
  • Images
• Don’t lose focus
• Develop your solution for a good reason
• Common Async Http
  
  • Volley
  • OkHttp
  • Retrofit
• Image Loading
  
  • Glide
  • Picasso
  • Fresco
  • UIL
• Pick 3rd party lib checklist
  
  • Solves your problem
  • Plays nicely with your current dependencies
  • Dex method count
  • Dependencies
  • Maintenance
  • Runtime permissions

4.Large JSONs

Large json

• Parsing has a performance effect
• Converted to class with getters and setters

JSON

• Small JSONs - GSON is the best
• Large JSONs -
  
  • FastJson
  • Jackson
  • GSON + immutables type adapters

So.Scrolling
+ Keep UI thread only for UI
+ Understand concurrency APIs
+ Use libraries (memory, caching, json…)
+ Use loaders

5.System abuse

System Abuse

• Don’t call private APIs by reflection
• Don’t call private native methods (NDK/C level)
• Don’t use Runtime.exex
• “adb shell am” to communicate with other process is not something we want to support
• Don’t abuse the System
• Know and use APIs

6.Deprecation

Deprecation

• API will be removed
• Your app will not work
• No way to update APIs and tools
• There is a compelling reason to move
  
  • Security
  • Correctness
  • Performance
• Know and use APIs
• Refactor you dependencies
• Update your dependencies and tools

Don’t use Apache Http Connection

• Removed at M (still available as dependency)
• *Use HttpURLConnection
  
  • Simple API
  • Small size
  • Transparent compression
  • Response caching

7.Bring your own gloves

Bring your own gloves

• Various versions, devices, OEMs
• APIs and libraries shipped with platform might behave differently
• Async task…
• Consider bundling your own version
• Check dex limit
• Check code bloat

Security

• Own wrapped library (SSL/crypto etc)
• Rooted devices
• Your own sensitive data/protocols

8.Architesture

Understand app components life cycle

• Activities
• Fragments
• Tasks
• Flags
• Add logs on callbacks

Work with framework not against

• Framework components have a purpose
• Specific semantics
• Don’t over engineer
• Keep simple

What you can do Architecture

• Consistent
• Get people on board quickly
• Have someone experienced
• Pick your dependencies wisely

Design your app for

• Sleeping most of the time
• Responsive when “awaken”

9.Know your APK

Know your executable

• Dex limit numbers
• Obfuscation
• Package counts
• Why I need the dependency

APK Analysis

• Native methods in multidex
• Interfaces + abstracts - LinearAlloc