Refactor WeakListenerManager into ObjectManager and ListenerManager

Author: yongce

.idea/compiler.xml

@@ -14,8 +14,8 @@ import android.os.SystemClock
 import androidx.annotation.IntDef
 import androidx.annotation.VisibleForTesting
 import androidx.annotation.WorkerThread
+import me.ycdev.android.lib.common.manager.ListenerManager
 import me.ycdev.android.lib.common.utils.Preconditions
-import me.ycdev.android.lib.common.utils.WeakListenerManager
 import timber.log.Timber
 import java.util.concurrent.atomic.AtomicInteger
 
@@ -32,7 +32,7 @@ abstract class ServiceConnector<IServiceInterface> protected constructor(
 ) {
     protected var appContext: Context = cxt.applicationContext
 
-    protected var stateListeners = WeakListenerManager<ConnectStateListener>()
+    protected var stateListeners = ListenerManager<ConnectStateListener>(true)
     private val connectWaitLock = Any()
     private val state = AtomicInteger(STATE_DISCONNECTED)
     private var connectStartTime: Long = 0
@@ -94,7 +94,7 @@ abstract class ServiceConnector<IServiceInterface> protected constructor(
     }
 
     /**
-     * Add a connect state listener, using [WeakListenerManager] to manager listeners.
+     * Add a connect state listener, using [ListenerManager] to manager listeners.
      * Callbacks will be invoked in [.getConnectLooper] thread.
      */
     fun addListener(listener: ConnectStateListener) {

.idea/misc.xml

@@ -0,0 +1,60 @@
+package me.ycdev.android.lib.common.manager
+
+@Suppress("unused")
+open class ListenerManager<IListener : Any>(override val weakReference: Boolean) :
+    ObjectManager<IListener>(weakReference) {
+
+    /**
+     * Only invoked when invoke [addListener]
+     */
+    protected open fun onFirstListenerAdd() {
+        // nothing to do
+    }
+
+    /**
+     * Only invoked when invoke [removeListener]
+     */
+    protected open fun onLastListenerRemoved() {
+        // nothing to do
+    }
+
+    /**
+     * Override this method to notify the listener when registered.
+     */
+    protected open fun onListenerAdded(listener: IListener) {
+        // nothing to do
+    }
+
+    final override fun onFirstObjectAdd() {
+        onFirstListenerAdd()
+    }
+
+    final override fun onLastObjectRemoved() {
+        onLastListenerRemoved()
+    }
+
+    final override fun onObjectAdded(obj: IListener) {
+        onListenerAdded(obj)
+    }
+
+    /**
+     * Get the listeners count right now.
+     * But the returned value may be NOT accurate if [weakReference] is true.
+     * Some of the listeners may be already collected by GC.
+     */
+    val listenersCount: Int by ::objectsCount
+
+    fun addListener(listener: IListener) = super.addObject(listener)
+
+    fun addListener(listener: IListener, tag: String) = super.addObject(listener, tag)
+
+    fun removeListener(listener: IListener) = super.removeObject(listener)
+
+    fun notifyListeners(action: NotifyAction<IListener>) = super.notifyObjects(action)
+
+    fun notifyListeners(action: (IListener) -> Unit) = super.notifyObjects(action)
+
+    companion object {
+        private const val TAG = "ListenerManager"
+    }
+}

baseLib/src/main/java/me/ycdev/android/lib/common/ipc/ServiceConnector.kt

@@ -0,0 +1,5 @@
+package me.ycdev.android.lib.common.manager
+
+interface NotifyAction<IListener> {
+    fun notify(listener: IListener)
+}

baseLib/src/main/java/me/ycdev/android/lib/common/manager/ListenerManager.kt

@@ -0,0 +1,125 @@
+package me.ycdev.android.lib.common.manager
+
+import timber.log.Timber
+import java.lang.ref.WeakReference
+import java.util.ArrayList
+
+open class ObjectManager<IObject : Any>(open val weakReference: Boolean) {
+    private class ObjectInfo<IObject>(obj: IObject, val tag: String, weakReference: Boolean) {
+        private var obj: IObject? = null
+        private var holder: WeakReference<IObject>? = null
+
+        init {
+            if (weakReference) {
+                holder = WeakReference(obj)
+            } else {
+                this.obj = obj
+            }
+        }
+
+        fun getObject(): IObject? {
+            return obj ?: holder!!.get()
+        }
+    }
+
+    private val allObjects: MutableList<ObjectInfo<IObject>> = ArrayList()
+
+    /**
+     * Get the objects count right now.
+     * But the returned value may be NOT accurate if [weakReference] is true.
+     * Some of the objects may be already collected by GC.
+     */
+    val objectsCount: Int get() = allObjects.size
+
+    /**
+     * Only invoked when invoke [addObject]
+     */
+    protected open fun onFirstObjectAdd() {
+        // nothing to do
+    }
+
+    /**
+     * Only invoked when invoke [removeObject]
+     */
+    protected open fun onLastObjectRemoved() {
+        // nothing to do
+    }
+
+    /**
+     * Override this method to notify the listener when registered.
+     */
+    protected open fun onObjectAdded(obj: IObject) {
+        // nothing to do
+    }
+
+    fun addObject(obj: IObject) {
+        addObject(obj, obj::class.java.name)
+    }
+
+    /**
+     * @param tag Identity the object, for debug only
+     */
+    fun addObject(obj: IObject, tag: String) {
+        synchronized(allObjects) {
+            if (allObjects.size == 0) {
+                onFirstObjectAdd()
+            }
+            for (objectInfo in allObjects) {
+                if (obj == objectInfo.getObject()) return // skip duplicate object
+            }
+            allObjects.add(ObjectInfo(obj, tag, weakReference))
+        }
+
+        // Notify the listener to get initialized
+        onObjectAdded(obj)
+    }
+
+    fun removeObject(obj: IObject) {
+        synchronized(allObjects) {
+            var removed = false
+            for (i in 0 until allObjects.size) {
+                val objectInfo = allObjects[i]
+                if (obj == objectInfo.getObject()) {
+                    allObjects.removeAt(i)
+                    removed = true
+                    break
+                }
+            }
+            if (allObjects.size == 0 && removed) {
+                onLastObjectRemoved()
+            }
+        }
+    }
+
+    fun notifyObjects(action: NotifyAction<IObject>) {
+        notifyObjects { action.notify(it) }
+    }
+
+    fun notifyObjects(action: (IObject) -> Unit) {
+        synchronized(allObjects) {
+            // The object may remove itself!
+            val objectsCopied: List<ObjectInfo<IObject>> = ArrayList(allObjects)
+            for (i in objectsCopied.indices) {
+                val objectInfo = objectsCopied[i]
+                val obj: IObject? = objectInfo.getObject()
+                if (obj == null) {
+                    Timber.tag(TAG).e("object leak found: %s", objectInfo.tag)
+                    allObjects.remove(objectInfo)
+                } else {
+                    if (DEV_LOG) {
+                        Timber.tag(TAG).d("notify #%d: %s", i, objectInfo.tag)
+                    }
+                    action(obj)
+                }
+            }
+            if (DEV_LOG) {
+                Timber.tag(TAG).d("notify done, cur size: %d", allObjects.size)
+            }
+        }
+    }
+
+    companion object {
+        private const val TAG = "ObjectManager"
+        private const val DEV_LOG = false
+    }
+}

baseLib/src/main/java/me/ycdev/android/lib/common/manager/NotifyAction.kt

@@ -1,8 +1,8 @@
 package me.ycdev.android.lib.common.tracker
 
-import me.ycdev.android.lib.common.utils.WeakListenerManager
+import me.ycdev.android.lib.common.manager.ListenerManager
 
-abstract class WeakTracker<IListener : Any> : WeakListenerManager<IListener>() {
+abstract class WeakTracker<IListener : Any> : ListenerManager<IListener>(true) {
     protected abstract fun startTracker()
     protected abstract fun stopTracker()