Java AllocationInfo类代码示例

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
public void testParsingOnOneAllocationWithStackTrace() throws IOException {
  ByteBuffer data = putAllocationInfo(new String[]{"path.Foo", "path.Bar", "path.Baz"}, new String[]{"foo", "bar", "baz"},
          new String[]{"Foo.java", "Bar.java"}, new int[][]{{64, 0, 1, 3}},
          new short[][][]{{{1, 1, 1, -1}, {2, 0, 1, 2000}, {0, 2, 0, 10}}});
  AllocationInfo[] info = AllocationsParser.parse(data);
  assertEquals(1, info.length);

  AllocationInfo alloc = info[0];
  checkEntry(1, "path.Bar", 64, 0, alloc);
  checkFirstTrace("path.Bar", "bar", alloc);

  StackTraceElement[] elems = alloc.getStackTrace();
  assertEquals(3, elems.length);

  checkStackFrame("path.Bar", "bar", "Bar.java", -1, elems[0]);
  checkStackFrame("path.Baz", "foo", "Bar.java", 2000, elems[1]);
  checkStackFrame("path.Foo", "baz", "Foo.java", 10, elems[2]);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
public void insert(AllocationInfo alloc, int depth) {
  StackTraceElement[] stack = alloc.getStackTrace();
  if (depth < stack.length) {
    StackTraceElement element = stack[stack.length - 1 - depth];
    StackNode child = myChildrenMap.get(element);
    if (child == null) {
      child = new StackNode(element);
      myChildrenMap.put(element, child);
      addChild(child);
    }
    child.insert(alloc, depth + 1);
  }
  else {
    AllocNode allocNode = new AllocNode(alloc);
    addChild(allocNode);
  }
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
@Override
public void insert(@NotNull AllocationInfo alloc) {
  StackTraceElement[] trace = alloc.getStackTrace();
  String[] packages;
  if (trace.length > 0) {
    int match = 0;
    for (int i = 0; i < trace.length; i++) {
      if (myFilter.matcher(trace[i].getClassName()).matches()) {
        match = i;
        break;
      }
    }
    // TODO don't use the last trace, but use a user defined filter.
    String name = trace[match].getClassName();
    int ix = name.indexOf("$");
    name = ix >= 0 ? name.substring(0, ix) : name;
    packages = name.split("\\.");
  } else {
    packages = new String[] { "< Unknown >" };
  }
  insert(packages, alloc, 0);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
@Override
public String getColumnText(Object element, int columnIndex) {
    if (element instanceof AllocationInfo) {
        AllocationInfo alloc = (AllocationInfo)element;
        switch (columnIndex) {
            case 0:
                return Integer.toString(alloc.getAllocNumber());
            case 1:
                return Integer.toString(alloc.getSize());
            case 2:
                return alloc.getAllocatedClass();
            case 3:
                return Short.toString(alloc.getThreadId());
            case 4:
                return alloc.getFirstTraceClassName();
            case 5:
                return alloc.getFirstTraceMethodName();
        }
    }

    return null;
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
/**
 * Returns the current allocation selection or <code>null</code> if none is found.
 * If a {@link ISelection} object is specified, the first {@link AllocationInfo} from this
 * selection is returned, otherwise, the <code>ISelection</code> returned by
 * {@link TableViewer#getSelection()} is used.
 * @param selection the {@link ISelection} to use, or <code>null</code>
 */
private AllocationInfo getAllocationSelection(ISelection selection) {
    if (selection == null) {
        selection = mAllocationViewer.getSelection();
    }

    if (selection instanceof IStructuredSelection) {
        IStructuredSelection structuredSelection = (IStructuredSelection)selection;
        Object object = structuredSelection.getFirstElement();
        if (object instanceof AllocationInfo) {
            return (AllocationInfo)object;
        }
    }

    return null;
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
private AllocationInfo[] getFilteredAllocations(AllocationInfo[] allocations,
        String filterText) {
    ArrayList<AllocationInfo> results = new ArrayList<AllocationInfo>();
    // Using default locale here such that the locale-specific c
    Locale locale = Locale.getDefault();
    filterText = filterText.toLowerCase(locale);
    boolean fullTrace = mTraceFilterCheck.getSelection();

    for (AllocationInfo info : allocations) {
        if (info.filter(filterText, fullTrace, locale)) {
            results.add(info);
        }
    }

    return results.toArray(new AllocationInfo[results.size()]);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
public void testParsingOnOneAllocationWithoutStackTrace() throws IOException {
  ByteBuffer data =
          putAllocationInfo(new String[]{"path.Foo"}, new String[0], new String[0], new int[][]{{32, 4, 0, 0}}, new short[][][]{{}});
  AllocationInfo[] info = AllocationsParser.parse(data);
  assertEquals(1, info.length);

  AllocationInfo alloc = info[0];
  checkEntry(1, "path.Foo", 32, 4, alloc);
  checkFirstTrace(null, null, alloc);
  assertEquals(0, alloc.getStackTrace().length);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
public void testParsing() throws IOException {
  ByteBuffer data = putAllocationInfo(new String[]{"path.Red", "path.Green", "path.Blue", "path.LightCanaryishGrey"},
          new String[]{"eatTiramisu", "failUnitTest", "watchCatVideos", "passGo", "collectFakeMoney", "findWaldo"},
          new String[]{"Red.java", "SomewhatBlue.java", "LightCanaryishGrey.java"},
          new int[][]{{128, 8, 0, 2}, {16, 8, 2, 1}, {42, 2, 1, 3}},
          new short[][][]{{{1, 0, 1, 100}, {2, 5, 1, -2}}, {{0, 1, 0, -1}}, {{3, 4, 2, 10001}, {0, 3, 0, 0}, {2, 2, 1, 16}}});
  AllocationInfo[] info = AllocationsParser.parse(data);
  assertEquals(3, info.length);

  AllocationInfo alloc1 = info[0];
  checkEntry(3, "path.Red", 128, 8, alloc1);
  checkFirstTrace("path.Green", "eatTiramisu", alloc1);

  StackTraceElement[] elems1 = alloc1.getStackTrace();
  assertEquals(2, elems1.length);

  checkStackFrame("path.Green", "eatTiramisu", "SomewhatBlue.java", 100, elems1[0]);
  checkStackFrame("path.Blue", "findWaldo", "SomewhatBlue.java", -2, elems1[1]);

  AllocationInfo alloc2 = info[1];
  checkEntry(2, "path.Blue", 16, 8, alloc2);
  checkFirstTrace("path.Red", "failUnitTest", alloc2);

  StackTraceElement[] elems2 = alloc2.getStackTrace();
  assertEquals(1, elems2.length);

  checkStackFrame("path.Red", "failUnitTest", "Red.java", -1, elems2[0]);

  AllocationInfo alloc3 = info[2];
  checkEntry(1, "path.Green", 42, 2, alloc3);
  checkFirstTrace("path.LightCanaryishGrey", "collectFakeMoney", alloc3);

  StackTraceElement[] elems3 = alloc3.getStackTrace();
  assertEquals(3, elems3.length);

  checkStackFrame("path.LightCanaryishGrey", "collectFakeMoney", "LightCanaryishGrey.java", 10001, elems3[0]);
  checkStackFrame("path.Red", "passGo", "Red.java", 0, elems3[1]);
  checkStackFrame("path.Blue", "watchCatVideos", "SomewhatBlue.java", 16, elems3[2]);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
@NotNull
private MainTreeNode generateTree() {
  MainTreeNode tree = myGroupBy.create();
  for (AllocationInfo alloc : myAllocations) {
    tree.insert(alloc);
  }
  return tree;
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
@Override
public void insert(@NotNull AllocationInfo alloc) {
  short id = alloc.getThreadId();
  ThreadNode thread = myChildrenMap.get(id);
  if (thread == null) {
    thread = new ThreadNode(id);
    myChildrenMap.put(id, thread);
    addChild(thread);
  }
  thread.insert(alloc, 0);
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
public void insert(String[] packages, AllocationInfo alloc, int depth) {
  if (depth < packages.length) {
    String name = packages[depth];
    PackageNode node = myChildrenMap.get(name);
    if (node == null) {
      node = depth == packages.length - 1 ? new ClassNode(name) : new PackageNode(name);
      myChildrenMap.put(name, node);
      addChild(node);
    }
    node.insert(packages, alloc, depth + 1);
  } else {
    addChild(new AllocNode(alloc));
  }
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
@Override
public Object[] getElements(Object inputElement) {
    if (inputElement instanceof Client) {
        AllocationInfo[] allocs = ((Client)inputElement).getClientData().getAllocations();
        if (allocs != null) {
            if (mFilterText != null && mFilterText.length() > 0) {
                allocs = getFilteredAllocations(allocs, mFilterText);
            }
            Arrays.sort(allocs, mSorter);
            return allocs;
        }
    }

    return new Object[0];
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
/**
 * Updates the stack call of the currently selected thread.
 * <p/>
 * This <b>must</b> be called from the UI thread.
 */
private void updateAllocationStackCall() {
    Client client = getCurrentClient();
    if (client != null) {
        // get the current selection in the ThreadTable
        AllocationInfo selectedAlloc = getAllocationSelection(null);

        if (selectedAlloc != null) {
            updateAllocationStackTrace(selectedAlloc);
        } else {
            updateAllocationStackTrace(null);
        }
    }
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
private static void checkEntry(int order, String className, int size, int thread, AllocationInfo alloc) {
  assertEquals(order, alloc.getAllocNumber());
  assertEquals(className, alloc.getAllocatedClass());
  assertEquals(size, alloc.getSize());
  assertEquals(thread, alloc.getThreadId());
}
 

import com.android.ddmlib.AllocationInfo; //导入依赖的package包/类
private static void checkFirstTrace(String className, String methodName, AllocationInfo alloc) {
  assertEquals(className, alloc.getFirstTraceClassName());
  assertEquals(methodName, alloc.getFirstTraceMethodName());
}