完成bitmap重复的作业

duplicatedbitmapanalyzer/.gitignore

@@ -0,0 +1 @@
+/build

duplicatedbitmapanalyzer/build.gradle

@@ -0,0 +1,29 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 26
+
+
+
+    defaultConfig {
+        minSdkVersion 15
+        targetSdkVersion 26
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+
+}
+
+dependencies {
+    api 'com.squareup.haha:haha:2.0.4'
+}

duplicatedbitmapanalyzer/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

duplicatedbitmapanalyzer/src/androidTest/java/com/example/duplicatedbitmapanalyzer/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package com.example.duplicatedbitmapanalyzer;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getTargetContext();
+
+        assertEquals("com.example.duplicatedbitmapanalyzer.test", appContext.getPackageName());
+    }
+}

duplicatedbitmapanalyzer/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.duplicatedbitmapanalyzer" />

duplicatedbitmapanalyzer/src/main/java/com/hprof/bitmap/DuplicatedBitmapCheck.java

@@ -0,0 +1,185 @@
+package com.hprof.bitmap;
+
+import android.os.Debug;
+import android.text.TextUtils;
+
+import com.squareup.haha.perflib.ArrayInstance;
+import com.squareup.haha.perflib.ClassInstance;
+import com.squareup.haha.perflib.ClassObj;
+import com.squareup.haha.perflib.Heap;
+import com.squareup.haha.perflib.HprofParser;
+import com.squareup.haha.perflib.Instance;
+import com.squareup.haha.perflib.Snapshot;
+import com.squareup.haha.perflib.io.HprofBuffer;
+import com.squareup.haha.perflib.io.MemoryMappedFileBuffer;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class DuplicatedBitmapCheck {
+    private File mFile;
+
+    private DuplicatedBitmapCheck() {
+    }
+
+    private static class DuplicatedBitmapCheckHolder {
+        private static final DuplicatedBitmapCheck sInstance = new DuplicatedBitmapCheck();
+    }
+
+    public static DuplicatedBitmapCheck getInstance() {
+        return DuplicatedBitmapCheckHolder.sInstance;
+    }
+
+    public void dump(File file) {
+        //1.手动出发一次GC后获取hprof文件
+        triggerGc();
+        try {
+            //生成了Hprof文件
+            Debug.dumpHprofData(file.getAbsolutePath());
+            mFile = file;
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+
+    }
+
+    public void analyze() {
+        if (mFile == null || !mFile.exists()) {
+            return;
+        }
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                // 打开hprof文件
+                HprofBuffer bufferr = null;
+                try {
+                    bufferr = new MemoryMappedFileBuffer(mFile);
+
+                    HprofParser parser = new HprofParser(bufferr);
+                    Snapshot snapshot = parser.parse();
+                    // 获得Bitmap Class
+                    final ClassObj bitmapClass = snapshot.findClass("android.graphics.Bitmap");
+
+                    // 获得heap, 只需要分析app和default heap即可
+                    Heap heap = snapshot.getHeap("app");
+                    // 从heap中获得所有的Bitmap实例
+                    final List<Instance> bitmapInstances = bitmapClass.getHeapInstances(heap.getId());
+                    // 从Bitmap实例中获得buffer数组
+                    if (bitmapInstances == null || bitmapInstances.size() == 0) {
+                        //不存在相同的bitmap
+                        return;
+                    }
+
+                    int[] buffers = new int[bitmapInstances.size()];
+                    for (int i = 0; i < bitmapInstances.size(); i++) {
+                        ArrayInstance arrayInstance = HahaHelper.fieldValue(((ClassInstance) bitmapInstances.get(i)).getValues(), "mBuffer");
+                        buffers[i] = Arrays.hashCode(arrayInstance.getValues());
+
+                    }
+                    HashMap<Integer, ArrayList<Instance>> map = new HashMap<>();
+                    for (int i = 0; i < buffers.length; i++) {
+                        if (!map.containsKey(buffers[i])) {
+                            ArrayList<Instance> list = new ArrayList<>();
+                            list.add(bitmapInstances.get(i));
+                            map.put(buffers[i], list);
+                        } else {
+                            continue;
+                        }
+                        for (int j = i + 1; j < buffers.length; j++) {
+                            if (buffers[i] == buffers[j]) {
+                                map.get(buffers[i]).add(bitmapInstances.get(j));
+                            }
+                        }
+                    }
+                    StringBuilder sb = new StringBuilder();
+                    for (Map.Entry<Integer, ArrayList<Instance>> entry : map.entrySet()) {
+                        if (entry.getValue().size() > 1) {
+                            sb.append("duplicateCount:" + entry.getValue().size() + "\n");
+                            List<Instance> instances = entry.getValue();
+                            sb.append("stacks:" + "\n");
+                            String[] infos = new String[instances.size()];
+                            for (int i = 0; i < instances.size(); i++) {
+                                infos[i] = getTraceString(getTraceFromInstance(instances.get(i)));
+                            }
+                            Instance instance = instances.get(0);
+                            sb.append(Arrays.toString(infos) + "\n");
+                            sb.append("bufferHashcode:" + entry.getKey() + "\n");
+                            int width = HahaHelper.fieldValue(((ClassInstance) instance).getValues(), "mWidth");
+                            int height = HahaHelper.fieldValue(((ClassInstance) instance).getValues(), "mHeight");
+                            sb.append("width:" + width + "\n");
+                            sb.append("height:" + height + "\n");
+                            ArrayInstance arrayInstance = HahaHelper.fieldValue(((ClassInstance) instance).getValues(), "mBuffer");
+
+                            sb.append("bufferSize:" + arrayInstance.getValues().length);
+                        }
+                    }
+                    if (TextUtils.isEmpty(sb.toString())) {
+                        sb.append("no duplicatedBitmap" + "\n");
+                    }
+                    if (mDuplicatedBitmapListener != null) {
+                        mDuplicatedBitmapListener.bitmapInfo(sb.toString());
+                    }
+
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }).start();
+
+    }
+
+    public String getTraceString(ArrayList<Instance> trace) {
+        StringBuilder stringBuilder = new StringBuilder();
+        if (trace != null && trace.size() > 0) {
+            for (Instance instance : trace) {
+                stringBuilder.append(instance.getClassObj().getClassName());
+                stringBuilder.append("\n");
+            }
+        }
+        return stringBuilder.toString();
+    }
+
+    private static ArrayList<Instance> getTraceFromInstance(Instance instance) {
+        ArrayList<Instance> arrayList = new ArrayList<>();
+        Instance nextInstance = null;
+        while ((nextInstance = instance.getNextInstanceToGcRoot()) != null) {
+            arrayList.add(nextInstance);
+            instance = nextInstance;
+        }
+        return arrayList;
+    }
+
+
+    private void triggerGc() {
+        Runtime.getRuntime().gc();
+        enqueueReferences();
+        System.runFinalization();
+    }
+
+    private void enqueueReferences() {
+        // Hack. We don't have a programmatic way to wait for the reference queue daemon to move
+        // references to the appropriate queues.
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            throw new AssertionError();
+        }
+    }
+
+    public DuplicatedBitmapListener mDuplicatedBitmapListener;
+
+    public void setDuplicatedBitmapListener(DuplicatedBitmapListener listener) {
+        mDuplicatedBitmapListener = listener;
+    }
+
+    public interface DuplicatedBitmapListener {
+        void bitmapInfo(String info);
+    }
+}