Android Performance(3) Hierarchy Viewer-CSDN博客

本文链接：https://blog.csdn.net/liaoqianchuan00/article/details/23542373

转载请注明：http://blog.csdn.net/liaoqianchuan00/article/details/23542373

概述

Hierarchy Viewer允许你调试和优化你的UI界面，他向开发人员展示一个视图的层次结构，以及每个laytout中节点的performance信息。

功能介绍

打开Hierarchy View:Window->Open Perspective->Other..->HierarchyView.

选择我们要分析程序。点击下图所示红色图标位置。可以看见右边有3个面板，有Tree View， Tree Overview， Layout View。如果没有显示这些面板，可以在Window->Show View中选择打开。

1. TreeView

l 可以放大缩小TreeView，也可以点击拖拽来查看其他节点。

l 在Filter byclass or id输入框中输入string来查找相应的class或者id，比如查找textView3.找到的节点背景色将变为蓝色。

l 也可以点击TreeView面板上方的按钮来保存图片。

l 每个View节点中可以显示ViewClass，Object 地址，View ID，Performance的圆圈，View序号（在父控件中的序号，从0开始）

l 点击TreeView中得ListView节点，可以看见他上方出现了一个屏幕上该控件的缩略图。如下图。我们也可以点击Layout view中得相应控件来快速找到一个View。

l 接着我们点击下图中红色方框中得图标，可以看到ListView中包含的控件节点都多了3个原点，这3个原点有绿黄红三种颜色，黄色和红色表示耗时久。绿色正常，而第一个点表示计算这个View size的时间。第二个点表示创建这个view的时间。第三个点表示在屏幕上画这个view的消耗时间。

2. TreeOverView

你可以使用Tree OverView来更方便的移动TreeView视图。

3. PropertiesView

你选中的View节点的属性列表，你可以很方便的查看这些属性而不需要去查看源代码。

4. Layout View

另外一种展现View结构的方式，当你在TreeView中选中一个节点的时候，Layout View中会用红色来显示选中View的位置和大小等。在这个面板中，当你选中一个View的时候，会同时显示红色，白色，和浅红色区域，

l 红色：当前选中的view

l 浅红色：当前选中View的父控件。

l 白色：既不是当前选中View的父控件，也不是他得子空间。

问题：

为了安全性的保护，Hierarchy只能连接到开发者版本的android系统，如果你的机器是在商店或者运营商提供的机器，那么就会连接失败。解决方法是可以root你的机器，或者是用到ViewServer。

[2014-04-12 14:45:53 - ViewServerDevice]Unable todebug device: samsung-sm_n9008v-5d1a632d

[2014-04-12 14:45:53 - hierarchyviewer]Missingforwarded port for 5d1a632d。

1. 从https://github.com/romainguy/ViewServer处下载ViewServer文件，加入项目中，

2. 并且在Manifest中添加权限

<uses-permissionandroid:name="android.permission.INTERNET"/>

3. 在相应的Activity的onCreate，OnDestroy，onResume中添加相应的方法。

具体方法可参照ViewServer类的javadoc。

* Licensedunder the Apache License, Version 2.0 (the "License");

* you may notuse this file except in compliance with the License.

* You mayobtain a copy of the License at

* http://www.apache.org/licenses/LICENSE-2.0

* Unlessrequired by applicable law or agreed to in writing, software

* distributedunder the License is distributed on an "AS IS" BASIS,

* WITHOUTWARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See theLicense for the specific language governing permissions and

* limitationsunder the License.

package com.example.androidtest;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.lang.reflect.Method;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.HashMap;

import java.util.List;

import java.util.Map.Entry;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

importjava.util.concurrent.locks.ReentrantReadWriteLock;

import android.app.Activity;

import android.content.Context;

import android.content.pm.ApplicationInfo;

import android.os.Build;

import android.text.TextUtils;

import android.util.Log;

import android.view.View;

import android.view.ViewDebug;

/**

*This class can be used to enable the use of HierarchyViewer inside an

* application.HierarchyViewer is an Android SDK tool that can be used

* to inspectand debug the user interface of running applications. For

* securityreasons, HierarchyViewer does not work on production builds

* (forinstance phones bought in store.) By using this class, you can

* makeHierarchyViewer work on any device. You must be very careful

* however toonly enable HierarchyViewer when debugging your

*application.

* Touse this view server, your application must require the INTERNET

*permission.

* Therecommended way to use this API is to register activities when

* they arecreated, and to unregister them when they get destroyed:

* <pre>

* public classMyActivity extends Activity {

* public void onCreate(BundlesavedInstanceState) {

* super.onCreate(savedInstanceState);

* // Set content view, etc.

* ViewServer.get(this).addWindow(this);

* }

* public void onDestroy() {

* super.onDestroy();

* ViewServer.get(this).removeWindow(this);

* }

* public void onResume() {

* super.onResume();

* ViewServer.get(this).setFocusedWindow(this);

* }

* </pre>

*

* In a similarfashion, you can use this API with an InputMethodService:

*

* <pre>

* public classMyInputMethodService extends InputMethodService {

* public void onCreate() {

* super.onCreate();

* View decorView =getWindow().getWindow().getDecorView();

* String name ="MyInputMethodService";

* ViewServer.get(this).addWindow(decorView, name);

* }

* public void onDestroy() {

* super.onDestroy();

* View decorView =getWindow().getWindow().getDecorView();

* ViewServer.get(this).removeWindow(decorView);

* }

* public void onStartInput(EditorInfoattribute, boolean restarting) {

* super.onStartInput(attribute,restarting);

* View decorView =getWindow().getWindow().getDecorView();

* ViewServer.get(this).setFocusedWindow(decorView);

* }

* </pre>

public class ViewServer implements Runnable {

/**

* Thedefault port used to start view servers.

privatestatic final int VIEW_SERVER_DEFAULT_PORT = 4939;

privatestatic final int VIEW_SERVER_MAX_CONNECTIONS = 10;

privatestatic final String BUILD_TYPE_USER = "user";

// Debugfacility

privatestatic final String LOG_TAG = "ViewServer";

privatestatic final String VALUE_PROTOCOL_VERSION = "4";

privatestatic final String VALUE_SERVER_VERSION = "4";

// Protocolcommands

// Returnsthe protocol version

privatestatic final String COMMAND_PROTOCOL_VERSION = "PROTOCOL";

// Returnsthe server version

privatestatic final String COMMAND_SERVER_VERSION = "SERVER";

// Listsall of the available windows in the system

private staticfinal String COMMAND_WINDOW_MANAGER_LIST = "LIST";

// Keeps aconnection open and notifies when the list of windows changes

privatestatic final String COMMAND_WINDOW_MANAGER_AUTOLIST = "AUTOLIST";

// Returnsthe focused window

privatestatic final String COMMAND_WINDOW_MANAGER_GET_FOCUS = "GET_FOCUS";

privateServerSocket mServer;

privatefinal int mPort;

privateThread mThread;

privateExecutorService mThreadPool;

privatefinal List<WindowListener> mListeners =

newCopyOnWriteArrayList<ViewServer.WindowListener>();

privatefinal HashMap<View, String> mWindows = new HashMap<View, String>();

privatefinal ReentrantReadWriteLock mWindowsLock = new ReentrantReadWriteLock();

privateView mFocusedWindow;

privatefinal ReentrantReadWriteLock mFocusLock = new ReentrantReadWriteLock();

privatestatic ViewServer sServer;

/**

* Returnsa unique instance of the ViewServer. This method should only be

* calledfrom the main thread of your application. The server will have

* the samelifetime as your process.

* If yourapplication does not have the <code>android:debuggable</code>

* flag setin its manifest, the server returned by this method will

* be adummy object that does not do anything. This allows you to use

* the samecode in debug and release versions of your application.

* @paramcontext A Context used to check whether the application is

* debuggable, this can be theapplication context

publicstatic ViewServer get(Context context) {

ApplicationInfo info = context.getApplicationInfo();

if(BUILD_TYPE_USER.equals(Build.TYPE) &&

(info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {

if(sServer == null) {

sServer = new ViewServer(ViewServer.VIEW_SERVER_DEFAULT_PORT);

}

if(!sServer.isRunning()) {

try {

sServer.start();

} catch (IOException e) {

Log.d(LOG_TAG, "Error:", e);

}

} else{

sServer = new NoopViewServer();

}

returnsServer;

}

privateViewServer() {

mPort =-1;

}

/**

* Createsa new ViewServer associated with the specified window manager on the

*specified local port. The server is not started by default.

* @paramport The port for the server to listen to.

* @see #start()

privateViewServer(int port) {

mPort =port;

}

/**

* Startsthe server.

* @returnTrue if the server was successfully created, or false if it already exists.

* @throwsIOException If the server cannot be created.

* @see#stop()

* @see#isRunning()

* @seeWindowManagerService#startViewServer(int)

publicboolean start() throws IOException {

if(mThread != null) {

return false;

}

mThread = new Thread(this, "LocalView Server [port=" + mPort + "]");

mThreadPool = Executors.newFixedThreadPool(VIEW_SERVER_MAX_CONNECTIONS);

mThread.start();

returntrue;

}

/**

* Stopsthe server.

* @return True if the server was stopped,false if an error occurred or if the

* server wasn't started.

* @see#start()

* @see#isRunning()

* @seeWindowManagerService#stopViewServer()

publicboolean stop() {

if(mThread != null) {

mThread.interrupt();

if(mThreadPool != null) {

try {

mThreadPool.shutdownNow();

} catch (SecurityException e) {

Log.w(LOG_TAG, "Could not stop all view server threads");

}

mThreadPool = null;

mThread = null;

try{

mServer.close();

mServer = null;

return true;

} catch (IOException e) {

Log.w(LOG_TAG, "Could not close the view server");

}

mWindowsLock.writeLock().lock();

try {

mWindows.clear();

}finally {

mWindowsLock.writeLock().unlock();

}

mFocusLock.writeLock().lock();

try {

mFocusedWindow = null;

}finally {

mFocusLock.writeLock().unlock();

}

returnfalse;

}

/**

*Indicates whether the server is currently running.

* @returnTrue if the server is running, false otherwise.

* @see#start()

* @see#stop()

* @seeWindowManagerService#isViewServerRunning()

publicboolean isRunning() {

return mThread != null &&mThread.isAlive();

}

/**

* Invokethis method to register a new view hierarchy.

* @paramactivity The activity whose view hierarchy/window to register

* @see#addWindow(View, String)

* @see #removeWindow(Activity)

public voidaddWindow(Activity activity) {

Stringname = activity.getTitle().toString();

if(TextUtils.isEmpty(name)) {

name = activity.getClass().getCanonicalName() +

"/0x" +System.identityHashCode(activity);

} else{

name += "(" + activity.getClass().getCanonicalName() +")";

}

addWindow(activity.getWindow().getDecorView(), name);

}

/**

* Invokethis method to unregister a view hierarchy.

* @paramactivity The activity whose view hierarchy/window to unregister

* @see#addWindow(Activity)

* @see#removeWindow(View)

public voidremoveWindow(Activity activity) {

removeWindow(activity.getWindow().getDecorView());

}

/**

* Invokethis method to register a new view hierarchy.

* @paramview A view that belongs to the view hierarchy/window to register

* @namename The name of the view hierarchy/window to register

* @see#removeWindow(View)

public voidaddWindow(View view, String name) {

mWindowsLock.writeLock().lock();

try {

mWindows.put(view.getRootView(), name);

}finally {

mWindowsLock.writeLock().unlock();

}

fireWindowsChangedEvent();

}

/**

* Invokethis method to unregister a view hierarchy.

* @paramview A view that belongs to the view hierarchy/window to unregister

* @see#addWindow(View, String)

public voidremoveWindow(View view) {

mWindowsLock.writeLock().lock();

try {

mWindows.remove(view.getRootView());

}finally {

mWindowsLock.writeLock().unlock();

}

fireWindowsChangedEvent();

}

/**

* Invokethis method to change the currently focused window.

* @paramactivity The activity whose view hierarchy/window hasfocus,

* or null to remove focus

public voidsetFocusedWindow(Activity activity) {

setFocusedWindow(activity.getWindow().getDecorView());

}

/**

* Invokethis method to change the currently focused window.

* @paramview A view that belongs to the view hierarchy/window that has focus,

* or null to remove focus

public voidsetFocusedWindow(View view) {

mFocusLock.writeLock().lock();

try {

mFocusedWindow = view == null ? null : view.getRootView();

}finally {

mFocusLock.writeLock().unlock();

}

fireFocusChangedEvent();

}

/**

* Mainserver loop.

public voidrun() {

try {

mServer = new ServerSocket(mPort, VIEW_SERVER_MAX_CONNECTIONS,InetAddress.getLocalHost());

} catch(Exception e) {

Log.w(LOG_TAG, "Starting ServerSocket error: ", e);

}

while(mServer != null && Thread.currentThread() == mThread) {

//Any uncaught exception will crash the system process

try{

Socket client = mServer.accept();

if (mThreadPool != null) {

mThreadPool.submit(new ViewServerWorker(client));

} else {

try {

client.close();

} catch (IOException e) {

e.printStackTrace();

}

}catch (Exception e) {

Log.w(LOG_TAG, "Connection error: ", e);

}

privatestatic boolean writeValue(Socket client, String value) {

booleanresult;

BufferedWriter out = null;

try {

OutputStream clientStream = client.getOutputStream();

out= new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);

out.write(value);

out.write("\n");

out.flush();

result = true;

} catch(Exception e) {

result = false;

}finally {

if(out != null) {

try {

out.close();

} catch (IOException e) {

result = false;

}

returnresult;

}

privatevoid fireWindowsChangedEvent() {

for(WindowListener listener : mListeners) {

listener.windowsChanged();

}

privatevoid fireFocusChangedEvent() {

for(WindowListener listener : mListeners) {

listener.focusChanged();

}

privatevoid addWindowListener(WindowListener listener) {

if(!mListeners.contains(listener)) {

mListeners.add(listener);

}

privatevoid removeWindowListener(WindowListener listener) {

mListeners.remove(listener);

}

privateinterface WindowListener {

voidwindowsChanged();

voidfocusChanged();

}

privatestatic class UncloseableOutputStream extends OutputStream {

privatefinal OutputStream mStream;

UncloseableOutputStream(OutputStream stream) {

mStream = stream;

}

publicvoid close() throws IOException {

//Don't close the stream

}

public boolean equals(Object o) {

return mStream.equals(o);

}

publicvoid flush() throws IOException {

mStream.flush();

}

publicint hashCode() {

return mStream.hashCode();

}

public String toString() {

return mStream.toString();

}

publicvoid write(byte[] buffer, int offset, int count)

throws IOException {

mStream.write(buffer, offset, count);

}

publicvoid write(byte[] buffer) throws IOException {

mStream.write(buffer);

}

publicvoid write(int oneByte) throws IOException {

mStream.write(oneByte);

}

privatestatic class NoopViewServer extends ViewServer {

privateNoopViewServer() {

}

@Override

publicboolean start() throws IOException {

return false;

}

@Override

publicboolean stop() {

return false;

}

@Override

publicboolean isRunning() {

return false;

}

@Override

publicvoid addWindow(Activity activity) {

}

@Override

publicvoid removeWindow(Activity activity) {

}

@Override

publicvoid addWindow(View view, String name) {

}

@Override

publicvoid removeWindow(View view) {

}

@Override

publicvoid setFocusedWindow(Activity activity) {

}

@Override

publicvoid setFocusedWindow(View view) {

}

@Override

publicvoid run() {

}

privateclass ViewServerWorker implements Runnable, WindowListener {

privateSocket mClient;

privateboolean mNeedWindowListUpdate;

privateboolean mNeedFocusedWindowUpdate;

privatefinal Object[] mLock = new Object[0];

publicViewServerWorker(Socket client) {

mClient = client;

mNeedWindowListUpdate = false;

mNeedFocusedWindowUpdate = false;

}

publicvoid run() {

BufferedReader in = null;

try{

in = new BufferedReader(new InputStreamReader(mClient.getInputStream()),1024);

final String request = in.readLine();

String command;

String parameters;

int index = request.indexOf(' ');

if (index == -1) {

command = request;

parameters = "";

} else {

command = request.substring(0, index);

parameters = request.substring(index + 1);

}

boolean result;

if (COMMAND_PROTOCOL_VERSION.equalsIgnoreCase(command)) {

result = writeValue(mClient, VALUE_PROTOCOL_VERSION);

} else if (COMMAND_SERVER_VERSION.equalsIgnoreCase(command)) {

result = writeValue(mClient, VALUE_SERVER_VERSION);

} else if(COMMAND_WINDOW_MANAGER_LIST.equalsIgnoreCase(command)) {

result = listWindows(mClient);

} else if (COMMAND_WINDOW_MANAGER_GET_FOCUS.equalsIgnoreCase(command)) {

result = getFocusedWindow(mClient);

} else if (COMMAND_WINDOW_MANAGER_AUTOLIST.equalsIgnoreCase(command)) {

result = windowManagerAutolistLoop();

} else {

result = windowCommand(mClient, command, parameters);

}

if (!result) {

Log.w(LOG_TAG, "An error occurred with the command: " +command);

}

}catch(IOException e) {

Log.w(LOG_TAG, "Connection error: ", e);

}finally {

if (in != null) {

try {

in.close();

} catch (IOException e) {

e.printStackTrace();

}

if (mClient != null) {

try {

mClient.close();

} catch (IOException e) {

e.printStackTrace();

}

privateboolean windowCommand(Socket client, String command, String parameters) {

boolean success = true;

BufferedWriter out = null;

try{

// Find the hash code of the window

int index = parameters.indexOf(' ');

if (index == -1) {

index = parameters.length();

}

final String code = parameters.substring(0, index);

int hashCode = (int) Long.parseLong(code, 16);

// Extract the command's parameter after the window description

if (index < parameters.length()) {

parameters = parameters.substring(index + 1);

} else {

parameters = "";

}

final View window = findWindow(hashCode);

if (window == null) {

return false;

}

// call stuff

final Method dispatch =ViewDebug.class.getDeclaredMethod("dispatchCommand",

View.class,String.class, String.class, OutputStream.class);

dispatch.setAccessible(true);

dispatch.invoke(null, window, command, parameters,

newUncloseableOutputStream(client.getOutputStream()));

if (!client.isOutputShutdown()) {

out = new BufferedWriter(newOutputStreamWriter(client.getOutputStream()));

out.write("DONE\n");

out.flush();

}

}catch (Exception e) {

Log.w(LOG_TAG, "Could not send command " + command +

" with parameters" + parameters, e);

success = false;

}finally {

if (out != null) {

try {

out.close();

} catch (IOException e) {

success = false;

}

return success;

}

privateView findWindow(int hashCode) {

if(hashCode == -1) {

View window = null;

mWindowsLock.readLock().lock();

try {

window = mFocusedWindow;

} finally {

mWindowsLock.readLock().unlock();

}

return window;

}

mWindowsLock.readLock().lock();

try {

for (Entry<View, String> entry : mWindows.entrySet()) {

if (System.identityHashCode(entry.getKey()) == hashCode) {

return entry.getKey();

}

} finally {

mWindowsLock.readLock().unlock();

}

return null;

}

privateboolean listWindows(Socket client) {

boolean result = true;

BufferedWriter out = null;

try{

mWindowsLock.readLock().lock();

OutputStream clientStream = client.getOutputStream();

out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 *1024);

for (Entry<View, String> entry : mWindows.entrySet()) {

out.write(Integer.toHexString(System.identityHashCode(entry.getKey())));

out.write(' ');

out.append(entry.getValue());

out.write('\n');

}

out.write("DONE.\n");

out.flush();

}catch (Exception e) {

result = false;

}finally {

mWindowsLock.readLock().unlock();

if (out != null) {

try {

out.close();

} catch (IOException e) {

result = false;

}

return result;

}

privateboolean getFocusedWindow(Socket client) {

boolean result = true;

String focusName = null;

BufferedWriter out = null;

try{

OutputStream clientStream = client.getOutputStream();

out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 *1024);

View focusedWindow = null;

mFocusLock.readLock().lock();

try {

focusedWindow = mFocusedWindow;

} finally {

mFocusLock.readLock().unlock();

}

if (focusedWindow != null) {

mWindowsLock.readLock().lock();

try {

focusName =mWindows.get(mFocusedWindow);

} finally {

mWindowsLock.readLock().unlock();

}

out.write(Integer.toHexString(System.identityHashCode(focusedWindow)));

out.write(' ');

out.append(focusName);

}

out.write('\n');

out.flush();

}catch (Exception e) {

result = false;

}finally {

if (out != null) {

try {

out.close();

} catch (IOException e) {

result = false;

}

return result;

}

publicvoid windowsChanged() {

synchronized (mLock) {

mNeedWindowListUpdate = true;

mLock.notifyAll();

}

publicvoid focusChanged() {

synchronized (mLock) {

mNeedFocusedWindowUpdate = true;

mLock.notifyAll();

}

privateboolean windowManagerAutolistLoop() {

addWindowListener(this);

BufferedWriter out = null;

try{

out = new BufferedWriter(newOutputStreamWriter(mClient.getOutputStream()));

while (!Thread.interrupted()) {

boolean needWindowListUpdate = false;

boolean needFocusedWindowUpdate = false;

synchronized (mLock) {

while(!mNeedWindowListUpdate && !mNeedFocusedWindowUpdate) {

mLock.wait();

}

if (mNeedWindowListUpdate) {

mNeedWindowListUpdate = false;

needWindowListUpdate = true;

}

if(mNeedFocusedWindowUpdate) {

mNeedFocusedWindowUpdate = false;

needFocusedWindowUpdate = true;

}

if (needWindowListUpdate) {

out.write("LISTUPDATE\n");

out.flush();

}

if (needFocusedWindowUpdate) {

out.write("FOCUSUPDATE\n");

out.flush();

}

}catch (Exception e) {

Log.w(LOG_TAG, "Connection error: ", e);

}finally {

if (out != null) {

try {

out.close();

} catch (IOException e) {

// Ignore

}

removeWindowListener(this);

}

return true;

}