1.LeakNodeStatus 三个状态，没用到

internal enum class LeakNodeStatus {
  NOT_LEAKING,
  LEAKING,
  UNKNOWN;
}

2.HeapAnalysisException 封装throwable

class HeapAnalysisException(cause: Throwable) : RuntimeException(cause) {

  override fun toString(): String {
    val stringWriter = StringWriter()
    cause!!.printStackTrace(PrintWriter(stringWriter))
    return stringWriter.toString()
  }

  companion object {
    private const val serialVersionUID: Long = -2522323377375290608
  }
}

3.AppSingletonInspector App范围内的单例，标记为不泄漏

/**
 * Inspector that automatically marks instances of the provided class names as not leaking
 * because they're app wide singletons.
 * 检查器，自动将提供的类名的实例标记为不泄漏，因为它们是应用程序范围的单例。
 *
 */
class AppSingletonInspector(private vararg val singletonClasses: String) : ObjectInspector {

    //检查
    override fun inspect(
            reporter: ObjectReporter//todo ObjectReporter是干哈的
    ) {
        if (reporter.heapObject is HeapInstance) {
            reporter.heapObject.instanceClass
                    .classHierarchy//他自己的类+父类
                    .forEach { heapClass ->
                        if (heapClass.name in singletonClasses) {
                            reporter.notLeakingReasons += "${heapClass.name} is an app singleton"
                        }
                    }
        }
    }
}

4.MetadataExtractor 元数据提取器接口

/**
 * Extracts metadata from a hprof to be reported in [HeapAnalysisSuccess.metadata].
 *
 * This is a functional interface with which you can create a [MetadataExtractor] from a lambda.
 * 从 [HeapAnalysisSuccess.metadata] 分析成功的 hprof 中提取元数据。
 * 这是一个功能接口，您可以使用它从 lambda 创建 [MetadataExtractor]。
 */
fun interface MetadataExtractor {
  fun extractMetadata(graph: HeapGraph): Map<String, String>

  companion object {

    /**
     * A no-op [MetadataExtractor]
     */
    val NO_OP = MetadataExtractor { emptyMap() }

    /**
     * Utility function to create a [MetadataExtractor] from the passed in [block] lambda instead of
     * using the anonymous `object : MetadataExtractor` syntax.
     *
     * Usage:
     *
     * ```kotlin
     * val inspector = MetadataExtractor { graph ->
     *
     * }
     * ```
     */
    inline operator fun invoke(crossinline block: (HeapGraph) -> Map<String, String>): MetadataExtractor =
      object : MetadataExtractor {
        override fun extractMetadata(graph: HeapGraph): Map<String, String> = block(graph)
      }
  }
}

5.LeakingObjectFinder查找泄漏的对象id们

/**
 * Finds the objects that are leaking, for which Shark will compute
 * leak traces.
 *
 * This is a functional interface with which you can create a [LeakingObjectFinder] from a lambda.
 * 查找泄漏的对象，Shark 将为其计算泄漏跟踪。 
 * 这是一个函数式接口，您可以使用它从 lambda 创建 [LeakingObjectFinder]。
 */
fun interface LeakingObjectFinder {

  /**
   * For a given heap graph, returns a set of object ids for the objects that are leaking.
   * 对于给定的堆图，返回一组泄漏对象的对象 ID。
   */
  fun findLeakingObjectIds(graph: HeapGraph): Set<Long>

  companion object {
    /**
     * Utility function to create a [LeakingObjectFinder] from the passed in [block] lambda
     * instead of using the anonymous `object : LeakingObjectFinder` syntax.
     *
     * Usage:
     *
     * ```kotlin
     * val listener = LeakingObjectFinder {
     *
     * }
     * ```
     */
    inline operator fun invoke(crossinline block: (HeapGraph) -> Set<Long>): LeakingObjectFinder =
      object : LeakingObjectFinder {
        override fun findLeakingObjectIds(graph: HeapGraph): Set<Long> = block(graph)
      }
  }
}

6.FilteringLeakingObjectFinder通过扫描堆转储中的所有对象并将决策委托给[FilteringLeakingObjectFinder.LeakingObjectFilter]列表来查找泄漏的对象

/**
 * Finds the objects that are leaking by scanning all objects in the heap dump
 * and delegating the decision to a list of [FilteringLeakingObjectFinder.LeakingObjectFilter]
 * 通过扫描堆转储中的所有对象并将决策委托给[FilteringLeakingObjectFinder.LeakingObjectFilter]列表来查找泄漏的对象
 */
class FilteringLeakingObjectFinder(private val filters: List<LeakingObjectFilter>) :
  LeakingObjectFinder {

  /**
   * Filter to be passed to the [FilteringLeakingObjectFinder] constructor.
   * 要传递给[FilteringLeakingObjectFinder]构造函数的筛选器。
   */
  interface LeakingObjectFilter {
    /**
     * Returns whether the passed in [heapObject] is leaking. This should only return true
     * when we're 100% sure the passed in [heapObject] should not be in memory anymore.
     * 返回传入的[heapObject]是否泄漏。只有当我们100%确定传入的[heapObject]不应再在内存中时，才会返回true。
     */
    fun isLeakingObject(heapObject: HeapObject): Boolean
  }

  override fun findLeakingObjectIds(graph: HeapGraph): Set<Long> {
    return graph.objects
      .filter { heapObject ->
        filters.any { filter ->//any表示至少有一个
          filter.isLeakingObject(heapObject)
        }
      }
      .map { it.objectId }
      .toSet()
  }
}

7.ObjectInspector为 LeakCanary 提供 堆中对象（类、实例和数组）更多的信息。

/**
 * Provides LeakCanary with insights about objects (classes, instances and arrays) found in the
 * heap. [inspect] will be called for each object that LeakCanary wants to know more about.
 * The implementation can then use the provided [ObjectReporter] to provide insights for that
 * object.
 *
 * 为 LeakCanary 提供 堆中对象（类、实例和数组）更多的信息。
 * LeakCanary可以调用[inspect]方法，了解对象更多的信息。
 * 实现类可以使用提供的 [ObjectReporter] 来提供该对象的信息。
 *
 * This is a functional interface with which you can create a [ObjectInspector] from a lambda.
 */
fun interface ObjectInspector {

  /**
   * @see [ObjectInspector]
   */
  fun inspect(reporter: ObjectReporter)//todo ObjectReporter干哈的

  companion object {
    /**
     * Utility function to create a [ObjectInspector] from the passed in [block] lambda instead of
     * using the anonymous `object : OnHeapAnalyzedListener` syntax.
     *
     * Usage:
     *
     * ```kotlin
     * val inspector = ObjectInspector { reporter ->
     *
     * }
     * ```
     */
    inline operator fun invoke(crossinline block: (ObjectReporter) -> Unit): ObjectInspector =
      object : ObjectInspector {
        override fun inspect(
          reporter: ObjectReporter
        ) {
          block(reporter)
        }
      }
  }
}