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

Je développe une application Android 2.3.3 avec un service. J'ai ceci à l'intérieur de ce service pour communiquer avec l'activité principale:

public class UDPListenerService extends Service
{
    private static final String TAG = "UDPListenerService";
    //private ThreadGroup myThreads = new ThreadGroup("UDPListenerServiceWorker");
    private UDPListenerThread myThread;
    /**
     * Handler to communicate from WorkerThread to service.
     */
    private Handler mServiceHandler;

    // Used to receive messages from the Activity
    final Messenger inMessenger = new Messenger(new IncomingHandler());
    // Use to send message to the Activity
    private Messenger outMessenger;

    class IncomingHandler extends Handler
    {
        @Override
        public void handleMessage(Message msg)
        {
        }
    }

    /**
     * Target we publish for clients to send messages to Incoming Handler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());
    [ ... ]
}

Et ici, final Messenger mMessenger = new Messenger(new IncomingHandler());je reçois l'avertissement Lint suivant:

This Handler class should be static or leaks might occur: IncomingHandler

Qu'est-ce que ça veut dire?

Si la IncomingHandlerclasse n'est pas statique, elle aura une référence à votre Serviceobjet.

Handler les objets pour le même thread partagent tous un objet Looper commun, dans lequel ils publient des messages et y lisent.

Comme les messages contiennent la cible Handler, tant qu'il y a des messages avec le gestionnaire cible dans la file d'attente de messages, le gestionnaire ne peut pas être récupéré. Si le gestionnaire n'est pas statique, votre Serviceou Activityne peut pas être récupéré, même après avoir été détruit.

Cela peut entraîner des fuites de mémoire, du moins pendant un certain temps - tant que les messages restent dans la file d'attente. Ce n'est pas vraiment un problème à moins que vous ne publiez des messages retardés.

Vous pouvez rendre IncomingHandlerstatique et avoir un WeakReferenceservice à votre disposition:

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 cet article de Romain Guy pour plus de référence

Comme d'autres l'ont mentionné, l'avertissement Lint est dû à une fuite de mémoire potentielle. Vous pouvez éviter l'avertissement Lint en passant un Handler.Callbacklors de la construction Handler(c'est-à-dire que vous ne sous Handler- classe pas et qu'il n'y a pas de Handlerclasse interne non statique):

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

Si je comprends bien, cela n'évitera pas la fuite de mémoire potentielle. Messageles objets contiennent une référence à l' mIncomingHandlerobjet qui contient une référence l' Handler.Callbackobjet qui contient une référence à l' Serviceobjet. Tant qu'il y aura des messages dans la Looperfile d'attente de messages, le Servicene sera pas GC. Cependant, ce ne sera pas un problème grave, sauf si vous avez des messages à retard long dans la file d'attente de messages.

Voici un exemple générique d'utilisation d'une référence faible et d'une classe de gestionnaire statique pour résoudre le problème (comme recommandé dans la documentation 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);
  }
}

De cette façon, cela a bien fonctionné pour moi, maintient le code propre en gardant où vous gérez le message dans sa propre classe interne.

Le gestionnaire que vous souhaitez utiliser

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

La classe intérieure

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

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

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 cela est étanche. Peut-être que quelqu'un pourrait commenter ceci:

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

    ...

}

Je ne suis pas sûr mais vous pouvez essayer d'initialiser le gestionnaire à null dans onDestroy ()

Je suis confus. L'exemple que j'ai trouvé évite complètement la propriété statique et utilise le thread d'interface utilisateur:

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

Ce que j'aime dans cette solution, c'est qu'il n'y a aucun problème à mélanger les variables de classe et de méthode.