Этот класс обработчика должен быть статическим или может возникнуть утечка: IncomingHandler

Ответ 1

Если класс IncomingHandler не является статичным, он будет ссылаться на ваш объект Service.

Handler объекты для одного и того же потока имеют общий объект Looper, из которого они отправляют сообщения и считывают их.

Как сообщения содержат target Handler, если в очереди сообщений есть сообщения с целевым обработчиком, обработчик не может собирать мусор. Если обработчик не является статическим, ваши Service или Activity не могут быть собраны в мусор, даже после их уничтожения.

Это может привести к утечке памяти в течение некоторого времени - до тех пор, пока сообщения остаются в очереди. Это не большая проблема, если вы не отправляете сообщения с длительной задержкой.

Вы можете сделать IncomingHandler static и иметь WeakReference для вашей службы:

static class IncomingHandler extends Handler {
    private final WeakReference<UDPListenerService> mService; 

    IncomingHandler(UDPListenerService service) {
        mService = new WeakReference<UDPListenerService>(service);
    }
    @Override
    public void handleMessage(Message msg)
    {
         UDPListenerService service = mService.get();
         if (service != null) {
              service.handleMessage(msg);
         }
    }
}

См. эту статью от Ромена Гая для дальнейшей справки

Ответ 2

Как отмечали другие, предупреждение Lint связано с потенциальной утечкой памяти. Вы можете избежать предупреждения Lint, передав Handler.Callback при построении Handler (т.е. Вы не подклассом Handler и не существует нестатического внутреннего класса Handler):

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

Как я понимаю, это не позволит избежать потенциальной утечки памяти. Объекты Message содержат ссылку на объект mIncomingHandler, который содержит ссылку на объект Handler.Callback, который содержит ссылку на объект Service. Пока есть сообщения в очереди сообщений Looper, Service не будет GC. Тем не менее, это не будет серьезной проблемой, если у вас не будет длинной задержки сообщений в очереди сообщений.

Ответ 3

Ниже приведен общий пример использования слабого ссылочного и статического классов обработчика для решения проблемы (как рекомендовано в документации 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);
  }
}

Ответ 4

Этот способ работал хорошо для меня, сохраняет код чистым, сохраняя, где вы обрабатываете сообщение в своем собственном внутреннем классе.

Обработчик, который вы хотите использовать

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

Внутренний класс

class IncomingHandlerCallback implements Handler.Callback{

    @Override
    public boolean handleMessage(Message message) {

        // Handle message code

        return true;
    }

Ответ 5

Я не уверен, но вы можете попробовать обработчик intialising для null в onDestroy()

Ответ 6

С помощью ответа @Sogger я создал общий обработчик:

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);
        }
    }
}

Интерфейс:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Я использую его следующим образом. Но я не уверен на 100%, если это безопасно для утечки. Может быть, кто-то может прокомментировать это:

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;
        }
    }

    ...

}