Cette classe de Gestionnaire doit être statique ou des fuites peuvent se produire: IncomingHandler

Si IncomingHandler classe n'est pas statique, elle aura une référence à votre Service objet.

Handler objets pour le même thread tous partagent un Looper objet, qui de poster des messages et de la lecture.

Que les messages contiennent des cibles Handler, tant qu'il y a des messages à la cible de gestionnaire dans la file d'attente de messages, le gestionnaire ne peut pas être nettoyée. Si le gestionnaire n'est pas statique, votre Service ou Activity ne peut pas être nettoyée, même après avoir été détruit.

Cela peut conduire à des fuites de mémoire, pour quelque temps du moins, tant que les messages restent int la file d'attente. Ce n'est pas vraiment un problème, à moins que vous publiez, longtemps retardée, messages.

Vous pouvez faire IncomingHandler statique et un WeakReference à votre service:

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

Voir ce post par Romain Guy pour de plus amples référence

Ici est un exemple générique de l'utilisation d'une référence faible et statique de la classe de gestionnaire pour résoudre le problème (comme recommandé dans la Charpie de la documentation):

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

Avec l'aide de @Sogger réponse, j'ai créé un générique Gestionnaire:

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

L'interface:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Je l'utilise comme suit. Mais je ne suis pas sûr à 100% si c'est une fuite à la sécurité. Peut-être que quelqu'un pourrait faire un commentaire sur ce:

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

    ...

}