Diese Handler-Klasse sollte statisch sein, da sonst Lecks auftreten können: IncomingHandler

Ich entwickle eine Android 2.3.3-Anwendung mit einem Dienst. Ich habe dies in diesem Dienst, um mit der Hauptaktivität zu kommunizieren:

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

Und hier final Messenger mMessenger = new Messenger(new IncomingHandler());bekomme ich folgende Lint-Warnung:

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

Was bedeutet das?

Wenn IncomingHandler Klasse nicht statisch ist, enthält sie einen Verweis auf Ihr ServiceObjekt.

Handler Objekte für denselben Thread haben alle ein gemeinsames Looper-Objekt, an das sie Nachrichten senden und von denen sie lesen.

Da Nachrichten ein Ziel enthalten Handler, kann der Handler nicht mit Müll gesammelt werden, solange sich Nachrichten mit dem Zielhandler in der Nachrichtenwarteschlange befinden. Wenn der Handler nicht statisch ist, ist Ihr ServiceoderActivity lässt sich nicht Müll gesammelt, auch nach zerstört.

Dies kann zumindest für einige Zeit zu Speicherverlusten führen - solange die Nachrichten in der Warteschlange bleiben. Dies ist kein großes Problem, es sei denn, Sie veröffentlichen lange verzögerte Nachrichten.

Sie können IncomingHandlerstatisch machen und einen WeakReferencezu Ihrem Dienst haben:

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

Siehe diesen Beitrag von Romain Guy für weitere Referenz

Wie andere bereits erwähnt haben, ist die Lint-Warnung auf den möglichen Speicherverlust zurückzuführen. Sie können die Lint-Warnung vermeiden, indem Sie Handler.Callbackbeim Konstruieren ein übergeben Handler(dh Sie haben keine Unterklasse Handlerund es gibt keine Handlernicht statische innere Klasse):

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

So wie ich es verstehe, wird dies den möglichen Speicherverlust nicht vermeiden. MessageObjekte enthalten eine Referenz auf das mIncomingHandlerObjekt, das eine Referenz enthält. Das Handler.CallbackObjekt enthält eine Referenz auf das ServiceObjekt. Solange sich Nachrichten in der LooperNachrichtenwarteschlange befinden, Serviceist dies kein GC. Es wird jedoch kein ernstes Problem sein, es sei denn, Sie haben Nachrichten mit langer Verzögerung in der Nachrichtenwarteschlange.

Hier ist ein allgemeines Beispiel für die Verwendung einer schwachen Referenz- und statischen Handlerklasse zur Behebung des Problems (wie in der Lint-Dokumentation empfohlen):

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

Diese Methode hat bei mir gut funktioniert und den Code sauber gehalten, indem Sie die Stelle, an der Sie die Nachricht verarbeiten, in einer eigenen inneren Klasse aufbewahren.

Der Handler, den Sie verwenden möchten

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

Die innere Klasse

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

Mit Hilfe der Antwort von @ Sogger habe ich einen generischen Handler erstellt:

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

Die Schnittstelle:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Ich benutze es wie folgt. Ich bin mir aber nicht 100% sicher, ob dies auslaufsicher ist. Vielleicht könnte jemand dies kommentieren:

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

    ...

}

Ich bin nicht sicher, aber Sie können versuchen, den Handler in onDestroy () auf null zu setzen.

Ich bin verwirrt. Das Beispiel, das ich gefunden habe, vermeidet die statische Eigenschaft vollständig und verwendet den UI-Thread:

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

Was mir an dieser Lösung gefällt, ist, dass es kein Problem gibt, Klassen- und Methodenvariablen zu mischen.