Implementation Patterns: Replace Anonymous Runnables

Use these examples to guide the refactoring.

Pattern: Prefer Lambdas over Anonymous Classes

Anonymous classes implementing Single Abstract Method (SAM) interfaces add class metadata overhead. Converting them to lambdas allows D8/R8 to merge them via Lambda Grouping.

What is Lambda Grouping? If you have multiple lambdas of the same type (e.g. OnClickListener), D8/R8 merges them into a single compiled class containing a switch statement under the hood. Explicit anonymous classes (e.g., new OnClickListener() { ... }) cannot be merged by the compiler and are forced to compile as separate individual classes, inflating binary size.

Bad Pattern

mHandler.post(new Runnable() {
    @Override
    public void run() {
        showKeyboard();
    }
});

Good Pattern

mHandler.post(() -> showKeyboard());

Exception: Annotated Methods (Do NOT Refactor)

If the method in the anonymous class has annotations (e.g. @JavascriptInterface, test annotations, or @SuppressLint), it must remain an anonymous class. Java lambda syntax does not support annotating the implemented method. Do not attempt to move @SuppressLint to the field or enclosing method, as lint may still fail to suppress the warning on the lambda.

• Keep as Anonymous Class:

  javaCopy

  // Cannot be converted to lambda because run() requires @JavascriptInterface
  webView.addJavascriptInterface(new Runnable() {
    @Override
    @JavascriptInterface
    public void run() {
        doSomething();
    }
  }, "Host");
  

Exception: Use of this (Do NOT Refactor)

If the anonymous class body uses this to refer to the anonymous class instance itself, it cannot be converted to a lambda.

• Keep as Anonymous Class:

  javaCopy

  mHandler.post(new Runnable() {
      @Override
      public void run() {
          // 'this' refers to the Runnable instance, e.g., to remove itself
          mHandler.removeCallbacks(this);
      }
  });
  
  

Exception: References to Blank Final Fields in Field Initializers (Do NOT Refactor)

If the anonymous class is defined as a field initializer, and its body references a final field that is initialized in the constructor (a blank final field), it cannot be converted to a lambda. Lambdas in field initializers cannot reference fields that are not yet definitely assigned.

• Keep as Anonymous Class:

  javaCopy

  class MyComponent {
      // mStartSmoothIndeterminate is a field initializer
      private final Runnable mStartSmoothIndeterminate =
              new Runnable() {
                  @Override
                  public void run() {
                      // mAnimationLogic is blank final and initialized in constructor.
                      // Converting this to a lambda will cause a compile error:
                      // "variable mAnimationLogic might not have been initialized"
                      mAnimationLogic.reset();
                  }
              };
  
    private final AnimationLogic mAnimationLogic;
  
    public MyComponent() {
        mAnimationLogic = new AnimationLogic();
    }
  }
  

Exception: View.OnTouchListener (Do NOT Refactor)

Do not convert View.OnTouchListener to a lambda if it does not call View#performClick(). This will trigger a ClickableViewAccessibility lint warning (either new or by breaking a lint baseline), and suppressing this warning on a lambda is difficult without broad suppression annotations.

• Keep as Anonymous Class:

  javaCopy

  mView.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        // Does not call v.performClick()
        mGestureDetector.onTouchEvent(event);
        return false;
    }
  });