Leakcanary 解析

// 调用 content provider 的 onCreate 方法时会调用 AppWatcher manualInstall 方法完成初始化
  override fun onCreate(): Boolean {
    val application = context!!.applicationContext as Application
    AppWatcher.manualInstall(application)
    return true
  }

// 初始化代码，默认 5s 超时，默认的 watchers 为 构建包含四种的 watcher
  fun manualInstall(
    application: Application,
    retainedDelayMillis: Long = TimeUnit.SECONDS.toMillis(5),
    watchersToInstall: List<InstallableWatcher> = appDefaultWatchers(application)
  ) {
      // 1. 主线程判断
    checkMainThread()
    if (isInstalled) {
      throw IllegalStateException(
        "AppWatcher already installed, see exception cause for prior install call", installCause
      )
    }
    // 2. 设置的 delay 超时提醒时间需要大于 0
    check(retainedDelayMillis >= 0) {
      "retainedDelayMillis $retainedDelayMillis must be at least 0 ms"
    }
    installCause = RuntimeException("manualInstall() first called here")
    this.retainedDelayMillis = retainedDelayMillis
    // 3. debug 版本启动 LogcatShark
    if (application.isDebuggableBuild) {
      LogcatSharkLog.install()
    }
    // 4. 初始化 InternalLeakCanary
    /*
    InternalLeakCanary#invoke
    此回调中会初始化一些检测内存泄露过程中需要的对象：
    */
    // Requires AppWatcher.objectWatcher to be set
    LeakCanaryDelegate.loadLeakCanary(application)

    // 5. 通知几个监听器去 install 自己
    watchersToInstall.forEach {
      it.install()
    }
  }

// activity 
  override fun install() {
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
  }

// fragment and viewmodel
private val lifecycleCallbacks =
    object : Application.ActivityLifecycleCallbacks by noOpDelegate() {
      override fun onActivityCreated(
        activity: Activity,
        savedInstanceState: Bundle?
      ) {
        for (watcher in fragmentDestroyWatchers) {
          watcher(activity)
        }
      }
    }

  override fun install() {
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
  }  


  companion object {
    private const val ANDROIDX_FRAGMENT_CLASS_NAME = "androidx.fragment.app.Fragment"
    // 这里面都会针对 viewmodel 的 onclear 进行监听
    private const val ANDROIDX_FRAGMENT_DESTROY_WATCHER_CLASS_NAME =
      "leakcanary.internal.AndroidXFragmentDestroyWatcher"

    // Using a string builder to prevent Jetifier from changing this string to Android X Fragment
    @Suppress("VariableNaming", "PropertyName")
    private val ANDROID_SUPPORT_FRAGMENT_CLASS_NAME =
      StringBuilder("android.").append("support.v4.app.Fragment")
        .toString()
    private const val ANDROID_SUPPORT_FRAGMENT_DESTROY_WATCHER_CLASS_NAME =
      "leakcanary.internal.AndroidSupportFragmentDestroyWatcher"
  }  

// RootViewWatcher 的 install， 
  override fun install() {
    Curtains.onRootViewsChangedListeners += listener
  }

// RootViewSpy
RootViewsSpy.install()

return RootViewsSpy().apply {
        WindowManagerSpy.swapWindowManagerGlobalMViews { mViews ->
          delegatingViewList.apply { addAll(mViews) }
        }
      }

// WindowManagerSpy 功能
// Enables replacing WindowManagerGlobal.mViews with a custom ArrayList implementation.

// 反射拿到这个对象，然后去注册监听
  val className = if (SDK_INT > 16) {
      "android.view.WindowManagerGlobal"
    } else {
      "android.view.WindowManagerImpl"
    }

// service watcher 的 install
  override fun install() {
    checkMainThread()
    check(uninstallActivityThreadHandlerCallback == null) {
      "ServiceWatcher already installed"
    }
    check(uninstallActivityManager == null) {
      "ServiceWatcher already installed"
    }
    try {
      swapActivityThreadHandlerCallback { mCallback ->
        uninstallActivityThreadHandlerCallback = {
          swapActivityThreadHandlerCallback {
            mCallback
          }
        }
        Handler.Callback { msg ->
          if (msg.what == STOP_SERVICE) {
            val key = msg.obj as IBinder
            activityThreadServices[key]?.let {
              onServicePreDestroy(key, it)
            }
          }
          mCallback?.handleMessage(msg) ?: false
        }
      }
      swapActivityManager { activityManagerInterface, activityManagerInstance ->
        uninstallActivityManager = {
          swapActivityManager { _, _ ->
            activityManagerInstance
          }
        }
        Proxy.newProxyInstance(
          activityManagerInterface.classLoader, arrayOf(activityManagerInterface)
        ) { _, method, args ->
          if (METHOD_SERVICE_DONE_EXECUTING == method.name) {
            val token = args!![0] as IBinder
            if (servicesToBeDestroyed.containsKey(token)) {
              onServiceDestroyed(token)
            }
          }
          try {
            if (args == null) {
              method.invoke(activityManagerInstance)
            } else {
              method.invoke(activityManagerInstance, *args)
            }
          } catch (invocationException: InvocationTargetException) {
            throw invocationException.targetException
          }
        }
      }
    } catch (ignored: Throwable) {
      SharkLog.d(ignored) { "Could not watch destroyed services" }
    }
  }

  // 存起来如果泄露要通知的监听者
  private val onObjectRetainedListeners = mutableSetOf<OnObjectRetainedListener>()

  /**
   * References passed to [watch].
   */
   // 核心数据结构，这里存起来我们要监听的 key 弱引用
  private val watchedObjects = mutableMapOf<String, KeyedWeakReference>()

  // 弱引用队列
  private val queue = ReferenceQueue<Any>()

// 1. 将被监听的对象使用 弱引用 持有之
  @Synchronized override fun expectWeaklyReachable(
    watchedObject: Any,
    description: String
  ) {
    if (!isEnabled()) {
      return
    }
    // 2. 首先从 queue 里面搞出去一个弱引用队头的 对象
    removeWeaklyReachableObjects()
    /*
       3. key / watchTime / refrence
    */
    val key = UUID.randomUUID()
      .toString()
    val watchUptimeMillis = clock.uptimeMillis()
    /*
      这里构建是咱们的核心 
      class KeyedWeakReference(
        referent: Any,
        val key: String,
        val description: String,
        val watchUptimeMillis: Long,
        referenceQueue: ReferenceQueue<Any>
      ) : WeakReference<Any>(
        referent, referenceQueue
      ) 
     这里可以看到这个 keyed 是继承于 WeakRefreence 的，继承的时候将，reference queue 设置为我们这个了，所以 在 Java GC 回收的时候才会把这个放到 queue 里，这样我们才有了依据    
    */
    val reference =
      KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue)
    SharkLog.d {
      "Watching " +
        (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") +
        (if (description.isNotEmpty()) " ($description)" else "") +
        " with key $key"
    }

    // 4. 添加刚刚构建的 refrence 到 map
    watchedObjects[key] = reference
    // 5. executor 里去 exec 去
    checkRetainedExecutor.execute {
      moveToRetained(key)
    }
  }

// 5.1 看看这个 checkRetainedExecutor 是个啥，lambda 表达式，delay 5s 之后检测是否还在
checkRetainedExecutor = {
      check(isInstalled) {
        "AppWatcher not installed"
      }
      mainHandler.postDelayed(it, retainedDelayMillis)
    }

// 如果超时了这个对象还没有被移除，那么就是超时了
  @Synchronized private fun moveToRetained(key: String) {
    // 这里去尝试移除对应的对象，这里移除成功之后理论上 watchedObjects 这里就木有了，有就代表泄漏，妙啊，妙啊。  
    removeWeaklyReachableObjects()
    val retainedRef = watchedObjects[key]
    if (retainedRef != null) {
      retainedRef.retainedUptimeMillis = clock.uptimeMillis()
      onObjectRetainedListeners.forEach { it.onObjectRetained() }
    }
  }

// 尝试移除已经解除嫌疑滴对象，因为这里到达就说明正常释放了
  private fun removeWeaklyReachableObjects() {
    // WeakReferences are enqueued as soon as the object to which they point to becomes weakly
    // reachable. This is before finalization or garbage collection has actually happened.
    var ref: KeyedWeakReference?
    do {
      ref = queue.poll() as KeyedWeakReference?
      if (ref != null) {
        watchedObjects.remove(ref.key)
      }
    } while (ref != null)
  }