04 | 内存优化（下）：内存优化这件事，应该从哪里着手？

package com.ximalaya.ting.kid.bitmap

import com.google.gson.GsonBuilder
import com.squareup.haha.perflib.*
import com.squareup.haha.perflib.io.MemoryMappedFileBuffer
import com.squareup.leakcanary.*
import java.io.File
import java.io.FileOutputStream
import java.io.OutputStreamWriter
import java.util.*

/**
 * Created by yorek.liu 2020/5/14
 *
 * @author yorek.liu
 * email [email protected]
 */
private const val TAG = "DuplicateBitmapChecker"

class DuplicateBitmapChecker {

    private lateinit var mHprofFilePath: String
    private lateinit var mOutputDir: String
    private lateinit var mOutputFilePath: String

    fun init(hprofFilePath: String, outputDir: String, outputFilePath: String) {
        mHprofFilePath = hprofFilePath
        mOutputDir = outputDir
        mOutputFilePath = outputFilePath
    }

    fun parseHprof() {
        LogWrapper.i(TAG, "ready to parse hprof file: $mHprofFilePath")

        val hprofFile = File(mHprofFilePath)

        val buffer = MemoryMappedFileBuffer(hprofFile)
        val parser = HprofParser(buffer)
        val snapshot = parser.parse()
        snapshot.computeDominators()

        LogWrapper.i(TAG, "parse hprof file completed")

        val bitmapClasses = snapshot.findClasses("android.graphics.Bitmap")
        val heaps = snapshot.heaps

        LogWrapper.i(TAG, "bitmapClasses.size=${bitmapClasses.size}, heaps.size=${heaps.size}")

        val gson = GsonBuilder()
            .setPrettyPrinting()
            .disableHtmlEscaping()
            .create()

        val fileOutputStream = FileOutputStream(mOutputFilePath)
        val fileWriter = OutputStreamWriter(fileOutputStream)
        heaps.filter {
            it.name == "app" || it.name == "default"
        }.forEach { heap ->
            analyzeHeap(bitmapClasses, heap, snapshot).forEach { analyzerResult ->
                fileWriter.write(analyzerResult.toJson(gson))
            }
        }
        fileWriter.flush()
        fileWriter.close()
        fileOutputStream.close()

        LogWrapper.i(TAG, "save output to $mOutputFilePath")
        LogWrapper.i(TAG, "save outputImages to dir: $mOutputDir")
    }

    private fun analyzeHeap(bitmapClasses: MutableCollection<ClassObj>, heap: Heap, snapshot: Snapshot): List<AnalyzerResult> {
        val resultList = mutableListOf<AnalyzerResult>()
        bitmapClasses.forEach { bitmapClass ->
            val instances = bitmapClass.getHeapInstances(heap.id)
            LogWrapper.i(TAG, "======================================================")
            LogWrapper.i(TAG, "${instances.size} instances found in heap ${heap.name}")

            val hashCodeList = IntArray(instances.size) { 0 }
            val hashCode2InstanceMap = HashMap<Int, MutableList<Instance>>()
            LogWrapper.i(TAG, "calculating hashcode ...")
            for (i in instances.indices) {
                if (instances[i].distanceToGcRoot == Int.MAX_VALUE) {
                    continue
                }
                val hashCode = getHashCode(instances[i])
                hashCodeList[i] = hashCode
                var instanceList = hashCode2InstanceMap[hashCode]
                if (instanceList == null) {
                    instanceList = mutableListOf()
                    hashCode2InstanceMap[hashCode] = instanceList
                }
                instanceList.add(instances[i])
            }

            LogWrapper.i(TAG, "${hashCode2InstanceMap.size} bitmap instance found")
            hashCode2InstanceMap.values.forEachIndexed { index, instanceList ->
                if (instanceList.size == 0 || instanceList.size == 1) {
                    LogWrapper.i(TAG, "analyzing #$index: skip due to the size: ${instanceList.size}")
                    return@forEachIndexed
                }
                LogWrapper.i(TAG, "analyzing #$index ...")
                val analyzerResult = getAnalyzerResult(instanceList, snapshot)
                resultList.add(analyzerResult)
            }

            LogWrapper.i(TAG, "======================================================")
            LogWrapper.i(TAG, "")
        }

        return resultList
    }

    private fun getHashCode(instance: Instance): Int {
        val classInstanceValues = (instance as ClassInstance).values
        val buffer = fieldValue<ArrayInstance>(classInstanceValues, "mBuffer")
        return Arrays.hashCode(buffer.values)
    }

    private fun getAnalyzerResult(instanceList: List<Instance>, snapshot: Snapshot): AnalyzerResult {
        val instance = instanceList[0]
        val classInstanceValues = (instance as ClassInstance).values

        val buffer = fieldValue<ArrayInstance>(classInstanceValues, "mBuffer")
        val bitmapWidth = fieldValue<Int>(classInstanceValues, "mWidth")
        val bitmapHeight = fieldValue<Int>(classInstanceValues, "mHeight")

        val analyzerResult = AnalyzerResult()
        analyzerResult.duplicateCount = instanceList.size
        analyzerResult.bufferSize = buffer.size
        analyzerResult.width = bitmapWidth
        analyzerResult.height = bitmapHeight
        try {
            val method = buffer.javaClass.getDeclaredMethod("asRawByteArray", Int::class.java, Int::class.java)
            method.isAccessible = true
            val imageDataByteArray = method.invoke(buffer, 0, buffer.size) as ByteArray
            method.isAccessible = false
            analyzerResult.bufferHash = DigestUtil.getMD5String(imageDataByteArray)
            analyzerResult.imageOutput = getOutputImagePath(analyzerResult.bufferHash)
            ARGB8888_BitmapExtractor.outputImage(bitmapWidth, bitmapHeight, imageDataByteArray, analyzerResult.imageOutput)
        } catch (e: Exception) { }

        for (ins in instanceList) {
            val leakTrace = getLeakTrace(ins, snapshot)
            analyzerResult.stacks.add(leakTrace.parse())
        }

        return analyzerResult
    }

    private fun getLeakTrace(instance: Instance, snapshot: Snapshot): LeakTrace? {
        val noOpRefs = ExcludedRefs.builder().build()
        val heapAnalyzer = HeapAnalyzer(noOpRefs, AnalyzerProgressListener.NONE, emptyList())

        try {
            val method = heapAnalyzer.javaClass.getDeclaredMethod(
                "findLeakTrace",
                Long::class.java,
                Snapshot::class.java,
                Instance::class.java,
                Boolean::class.java
            )
            method.isAccessible = true
            val analyzerResult = method.invoke(
                heapAnalyzer,
                System.nanoTime(),
                snapshot,
                instance,
                false
            ) as AnalysisResult
            return analyzerResult.leakTrace
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
            return null
        }
    }

    private fun <T> fieldValue(values: List<ClassInstance.FieldValue>, fieldName: String): T {
        for (fieldValue in values) {
            if (fieldValue.field.name == fieldName) {
                return fieldValue.value as T
            }
        }
        throw java.lang.IllegalArgumentException("Field $fieldName does not exists")
    }

    private fun getOutputImagePath(fileName: String): String {
        return "$mOutputDir${File.separator}$fileName.png"
    }
}

package com.ximalaya.ting.kid.bitmap

/**
 * Created by yorek.liu 2020/5/14
 *
 * @author yorek.liu
 * email [email protected]
' */
object LogWrapper {

    private var mLogPrint: LogPrint = JavaLogPrint()

//    init {
//        try {
//            Class.forName("android.os.Build")
//            if (Build.VERSION.SDK_INT != 0) {
//                mLogPrint = AndroidLogPrint()
//            }
//        } catch (ignored: ClassNotFoundException) {
//            ignored.exception.printStackTrace()
//        }
//
//        if (!::mLogPrint.isInitialized) {
//            mLogPrint = JavaLogPrint()
//        }
//    }

    fun i(tag: String, message: String) {
        mLogPrint.i(tag, message)
    }

    abstract class LogPrint {
        abstract fun i(tag: String, message: String)
    }

    class AndroidLogPrint: LogPrint() {
        override fun i(tag: String, message: String) {
//            Log.i(tag, message)
        }
    }

    class JavaLogPrint: LogPrint() {
        override fun i(tag: String, message: String) {
            println(message)
        }
    }
}

package com.ximalaya.ting.kid.bitmap

import com.squareup.leakcanary.LeakTrace
import com.squareup.leakcanary.LeakTraceElement
import java.util.*

/**
 * Created by yorek.liu 2020/5/18
 *
 * @author yorek.liu
 * email [email protected]
 */
fun LeakTrace?.parse(): List<String> {
    val list = mutableListOf<String>()

    this ?: return list

    for (element in elements) {
        list.add(element.parse())
    }

    return list
}

fun LeakTraceElement.parse(): String {
    val stringBuilder = StringBuilder()

    if (reference !== null && reference.type === LeakTraceElement.Type.STATIC_FIELD) {
        stringBuilder.append("static ")
    }
    if (holder === LeakTraceElement.Holder.ARRAY || holder === LeakTraceElement.Holder.THREAD) {
        stringBuilder.append(holder.name.toLowerCase(Locale.getDefault())).append(" ")
    }

    stringBuilder.append(className)
    if (reference !== null) {
        stringBuilder.append(" ").append(reference.displayName)
        if (reference.value != null) {
            val subStringStart = reference.value.indexOf("(") + 1
            val subStringEnd = reference.value.indexOf(")")
            val refValueHashcode = reference.value.subSequence(subStringStart, subStringEnd)
            stringBuilder.append("(").append(refValueHashcode).append(")")
        }
    }

//    if (extra !== null) {
//        stringBuilder.append(" ").append(extra)
//    }

    return stringBuilder.toString()
}

package com.ximalaya.ting.kid.bitmap

import com.google.gson.Gson

/**
 * Created by yorek.liu 2020/5/14
 *
 * @author yorek.liu
 * email [email protected]
 */
class AnalyzerResult {
    var duplicateCount: Int = 0
    val stacks: MutableList<List<String>> = mutableListOf()
    var bufferHash: String = ""
    var imageOutput: String = ""
    var bufferSize: Int = 0
    var width: Int = 0
    var height: Int = 0

    fun toJson(gson: Gson): String {
        return gson.toJson(this)
    }
}