Ta klasa obsługi powinna być statyczna lub mogą wystąpić nieszczelności: IncomingHandler

Jak inni wspominali, Ostrzeżenie Lint jest spowodowane potencjalnym wyciekiem pamięci. Możesz uniknąć ostrzeżenia Lint przekazując Handler.Callback podczas konstruowania Handler (tzn. nie podklasujesz Handler i nie ma Handler niestatycznej klasy wewnętrznej):

Handler mIncomingHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        // todo
        return true;
    }
});

Jak rozumiem, nie uniknie to potencjalnego wycieku pamięci. Message obiekty przechowują odniesienie do mIncomingHandler obiektu, który przechowuje odniesienie Handler.Callback obiektu, który przechowuje odniesienie do Service obiektu. Dopóki są wiadomości w kolejce komunikatów Looper, Service nie będzie GC. Nie będzie to jednak poważny problem, jeśli w kolejce wiadomości nie będą wyświetlane komunikaty o dużym opóźnieniu.

Oto ogólny przykład użycia słabej klasy referencji i statycznej obsługi do rozwiązania problemu (zgodnie z zaleceniami w dokumentacji Lint):

public class MyClass{

  //static inner class doesn't hold an implicit reference to the outer class
  private static class MyHandler extends Handler {
    //Using a weak reference means you won't prevent garbage collection
    private final WeakReference<MyClass> myClassWeakReference; 

    public MyHandler(MyClass myClassInstance) {
      myClassWeakReference = new WeakReference<MyClass>(myClassInstance);
    }

    @Override
    public void handleMessage(Message msg) {
      MyClass myClass = myClassWeakReference.get();
      if (myClass != null) {
        ...do work here...
      }
    }
  }

  /**
   * An example getter to provide it to some external class
   * or just use 'new MyHandler(this)' if you are using it internally.
   * If you only use it internally you might even want it as final member:
   * private final MyHandler mHandler = new MyHandler(this);
   */
  public Handler getHandler() {
    return new MyHandler(this);
  }
}

Ten sposób zadziałał dobrze dla mnie, utrzymuje kod w czystości, utrzymując miejsce obsługi wiadomości we własnej klasie wewnętrznej.

Uchwyt, którego chcesz użyć

Handler mIncomingHandler = new Handler(new IncomingHandlerCallback());

Klasa wewnętrzna

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

Z Pomocą odpowiedzi @Sogger stworzyłem ogólny Handler:

public class MainThreadHandler<T extends MessageHandler> extends Handler {

    private final WeakReference<T> mInstance;

    public MainThreadHandler(T clazz) {
        // Remove the following line to use the current thread.
        super(Looper.getMainLooper());
        mInstance = new WeakReference<>(clazz);
    }

    @Override
    public void handleMessage(Message msg) {
        T clazz = mInstance.get();
        if (clazz != null) {
            clazz.handleMessage(msg);
        }
    }
}

Interfejs:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Używam go w następujący sposób. Ale nie jestem w 100% pewien, czy to jest bezpieczne. Może ktoś mógłby to skomentować:

public class MyClass implements MessageHandler {

    private static final int DO_IT_MSG = 123;

    private MainThreadHandler<MyClass> mHandler = new MainThreadHandler<>(this);

    private void start() {
        // Do it in 5 seconds.
        mHandler.sendEmptyMessageDelayed(DO_IT_MSG, 5 * 1000);
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case DO_IT_MSG:
                doIt();
                break;
        }
    }

    ...

}

Nie jestem pewien, ale możesz spróbować wprowadzić handler do null w onDestroy ()

Jestem zdezorientowany. Przykład, który znalazłem, całkowicie unika właściwości statycznej i używa wątku interfejsu użytkownika:

    public class example extends Activity {
        final int HANDLE_FIX_SCREEN = 1000;
        public Handler DBthreadHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                int imsg;
                imsg = msg.what;
                if (imsg == HANDLE_FIX_SCREEN) {
                    doSomething();
                }
            }
        };
    }

Rzecz, którą lubię w tym rozwiązaniu, to to, że nie ma problemu z mieszaniem zmiennych klasy i metody.