Bu Handler sınıfı statik olmalıdır veya sızıntı olabilir: IncomingHandler

Bir hizmet ile bir Android 2.3.3 uygulaması geliştiriyorum. Bu hizmet içinde Ana faaliyet ile iletişim kurmak için var:

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

Ve burada, final Messenger mMessenger = new Messenger(new IncomingHandler());aşağıdaki Lint uyarısını alıyorum:

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

Bu ne demek?

Eğer IncomingHandlersınıf statik değildir, bu bir başvuru olacaktır Servicenesne.

Handler aynı iş parçacığındaki nesnelerin tümü, ileti gönderdikleri ve okudukları ortak bir Looper nesnesini paylaşır.

İletiler hedef içerdiğinden Handler, ileti kuyruğunda hedef işleyiciye sahip iletiler olduğu sürece, işleyici çöp toplanamaz. İşleyici statik değilse, imha edildikten sonra bile çöpleriniz toplanamaz Serviceveya Activitytoplanamaz.

Bu, mesajlar kuyrukta kaldığı sürece en azından bir süreliğine bellek sızıntılarına neden olabilir. Uzun gecikmeli mesajlar göndermediğiniz sürece bu çok önemli değildir.

IncomingHandlerStatik yapabilir ve WeakReferencehizmetinize bir sahip olabilirsiniz :

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

Bu bak yazıyı daha fazla referans için Romain Guy tarafından

Diğerlerinin de belirttiği gibi Lint uyarısı, potansiyel bellek sızıntısından kaynaklanmaktadır. Yaparken bir Handler.Callbackzaman geçirerek Lint uyarısından kaçınabilirsiniz Handler(yani alt sınıf yapmazsınız Handlerve Handlerstatik olmayan bir iç sınıf yoktur):

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

Anladığım kadarıyla, bu potansiyel bellek sızıntısını önlemeyecektir. Messagenesneler, bir mIncomingHandlernesnenin başvurusunu Handler.Callbacktutan nesneye bir başvuru içerir Service. Looperİleti kuyruğunda iletiler olduğu sürece , ServiceGC olmaz. Ancak, ileti kuyruğunda uzun gecikme iletileri yoksa ciddi bir sorun olmaz.

Sorunu çözmek için zayıf bir referans ve statik işleyici sınıfı kullanmanın genel bir örneği (Lint belgelerinde önerildiği gibi):

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

Bu şekilde benim için iyi çalıştı, mesajı kendi iç sınıfında ele alarak kodu temiz tutar.

Kullanmak istediğiniz işleyici

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

İç sınıf

class IncomingHandlerCallback implements Handler.Callback{

        @Override
        public boolean handleMessage(Message message) {

            // Handle message code

            return true;
        }
}

@ Sogger'ın cevabının yardımıyla, genel bir Handler oluşturdum:

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

Arayüz:

public interface MessageHandler {

    void handleMessage(Message msg);

}

Aşağıdaki gibi kullanıyorum. Ama bunun sızdırmaz olup olmadığından% 100 emin değilim. Belki birisi bu konuda yorum yapabilir:

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

    ...

}

Emin değilim ama onDestroy () null için intialising işleyici deneyebilirsiniz

Kafam karıştı. Bulduğum örnek, statik özelliği tamamen önler ve UI iş parçacığını kullanır:

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

Bu çözüm hakkında sevdiğim şey, sınıf ve yöntem değişkenlerini karıştırmaya çalışırken sorun yok.