Java tutorial
/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.hierarchyviewerlib.device; import java.awt.Graphics2D; import java.awt.Point; import java.awt.image.BufferedImage; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.imageio.ImageIO; import org.apache.commons.io.FileUtils; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Display; import com.android.ddmlib.AdbCommandRejectedException; import com.android.ddmlib.AndroidDebugBridge; import com.android.ddmlib.IDevice; import com.android.ddmlib.Log; import com.android.ddmlib.MultiLineReceiver; import com.android.ddmlib.ShellCommandUnresponsiveException; import com.android.ddmlib.TimeoutException; import com.android.hierarchyviewerlib.ui.util.PsdFile; /** * A bridge to the device. */ public class DeviceBridge { public static final String TAG = "hierarchyviewer"; private static final int DEFAULT_SERVER_PORT = 4939; // These codes must match the auto-generated codes in IWindowManager.java // See IWindowManager.aidl as well private static final int SERVICE_CODE_START_SERVER = 1; private static final int SERVICE_CODE_STOP_SERVER = 2; private static final int SERVICE_CODE_IS_SERVER_RUNNING = 3; private static AndroidDebugBridge sBridge; private static final HashMap<IDevice, Integer> sDevicePortMap = new HashMap<IDevice, Integer>(); private static final HashMap<IDevice, ViewServerInfo> sViewServerInfo = new HashMap<IDevice, ViewServerInfo>(); private static int sNextLocalPort = DEFAULT_SERVER_PORT; public static class ViewServerInfo { public final int protocolVersion; public final int serverVersion; ViewServerInfo(int serverVersion, int protocolVersion) { this.protocolVersion = protocolVersion; this.serverVersion = serverVersion; } } /** * Init the DeviceBridge with an existing {@link AndroidDebugBridge}. * @param bridge the bridge object to use */ public static void acquireBridge(AndroidDebugBridge bridge) { sBridge = bridge; } /** * Creates an {@link AndroidDebugBridge} connected to adb at the given location. * * If a bridge is already running, this disconnects it and creates a new one. * * @param adbLocation the location to adb. */ public static void initDebugBridge(String adbLocation) { if (sBridge == null) { AndroidDebugBridge.init(false /* debugger support */); } if (sBridge == null || !sBridge.isConnected()) { sBridge = AndroidDebugBridge.createBridge(adbLocation, true); } } /** Disconnects the current {@link AndroidDebugBridge}. */ public static void terminate() { AndroidDebugBridge.terminate(); } public static IDevice[] getDevices() { if (sBridge == null) { return new IDevice[0]; } return sBridge.getDevices(); } /* * This adds a listener to the debug bridge. The listener is notified of * connecting/disconnecting devices, devices coming online, etc. */ public static void startListenForDevices(AndroidDebugBridge.IDeviceChangeListener listener) { AndroidDebugBridge.addDeviceChangeListener(listener); } public static void stopListenForDevices(AndroidDebugBridge.IDeviceChangeListener listener) { AndroidDebugBridge.removeDeviceChangeListener(listener); } /** * Sets up a just-connected device to work with the view server. * <p/> * This starts a port forwarding between a local port and a port on the * device. * * @param device */ public static void setupDeviceForward(IDevice device) { synchronized (sDevicePortMap) { if (device.getState() == IDevice.DeviceState.ONLINE) { int localPort = sNextLocalPort++; try { device.createForward(localPort, DEFAULT_SERVER_PORT); sDevicePortMap.put(device, localPort); } catch (TimeoutException e) { Log.e(TAG, "Timeout setting up port forwarding for " + device); } catch (AdbCommandRejectedException e) { Log.e(TAG, String.format("Adb rejected forward command for device %1$s: %2$s", device, e.getMessage())); } catch (IOException e) { Log.e(TAG, String.format("Failed to create forward for device %1$s: %2$s", device, e.getMessage())); } } } } public static void removeDeviceForward(IDevice device) { synchronized (sDevicePortMap) { final Integer localPort = sDevicePortMap.get(device); if (localPort != null) { try { device.removeForward(localPort, DEFAULT_SERVER_PORT); sDevicePortMap.remove(device); } catch (TimeoutException e) { Log.e(TAG, "Timeout removing port forwarding for " + device); } catch (AdbCommandRejectedException e) { // In this case, we want to fail silently. } catch (IOException e) { Log.e(TAG, String.format("Failed to remove forward for device %1$s: %2$s", device, e.getMessage())); } } } } public static int getDeviceLocalPort(IDevice device) { synchronized (sDevicePortMap) { Integer port = sDevicePortMap.get(device); if (port != null) { return port; } Log.e(TAG, "Missing forwarded port for " + device.getSerialNumber()); return -1; } } public static boolean isViewServerRunning(IDevice device) { final boolean[] result = new boolean[1]; try { if (device.isOnline()) { device.executeShellCommand(buildIsServerRunningShellCommand(), new BooleanResultReader(result)); if (!result[0]) { ViewServerInfo serverInfo = loadViewServerInfo(device); if (serverInfo != null && serverInfo.protocolVersion > 2) { result[0] = true; } } } } catch (TimeoutException e) { Log.e(TAG, "Timeout checking status of view server on device " + device); } catch (IOException e) { Log.e(TAG, "Unable to check status of view server on device " + device); } catch (AdbCommandRejectedException e) { Log.e(TAG, "Adb rejected command to check status of view server on device " + device); } catch (ShellCommandUnresponsiveException e) { Log.e(TAG, "Unable to execute command to check status of view server on device " + device); } return result[0]; } public static boolean startViewServer(IDevice device) { return startViewServer(device, DEFAULT_SERVER_PORT); } public static boolean startViewServer(IDevice device, int port) { final boolean[] result = new boolean[1]; try { if (device.isOnline()) { device.executeShellCommand(buildStartServerShellCommand(port), new BooleanResultReader(result)); } } catch (TimeoutException e) { Log.e(TAG, "Timeout starting view server on device " + device); } catch (IOException e) { Log.e(TAG, "Unable to start view server on device " + device); } catch (AdbCommandRejectedException e) { Log.e(TAG, "Adb rejected command to start view server on device " + device); } catch (ShellCommandUnresponsiveException e) { Log.e(TAG, "Unable to execute command to start view server on device " + device); } return result[0]; } public static boolean stopViewServer(IDevice device) { final boolean[] result = new boolean[1]; try { if (device.isOnline()) { device.executeShellCommand(buildStopServerShellCommand(), new BooleanResultReader(result)); } } catch (TimeoutException e) { Log.e(TAG, "Timeout stopping view server on device " + device); } catch (IOException e) { Log.e(TAG, "Unable to stop view server on device " + device); } catch (AdbCommandRejectedException e) { Log.e(TAG, "Adb rejected command to stop view server on device " + device); } catch (ShellCommandUnresponsiveException e) { Log.e(TAG, "Unable to execute command to stop view server on device " + device); } return result[0]; } private static String buildStartServerShellCommand(int port) { return String.format("service call window %d i32 %d", SERVICE_CODE_START_SERVER, port); //$NON-NLS-1$ } private static String buildStopServerShellCommand() { return String.format("service call window %d", SERVICE_CODE_STOP_SERVER); //$NON-NLS-1$ } private static String buildIsServerRunningShellCommand() { return String.format("service call window %d", SERVICE_CODE_IS_SERVER_RUNNING); //$NON-NLS-1$ } private static class BooleanResultReader extends MultiLineReceiver { private final boolean[] mResult; public BooleanResultReader(boolean[] result) { mResult = result; } @Override public void processNewLines(String[] strings) { if (strings.length > 0) { Pattern pattern = Pattern.compile(".*?\\([0-9]{8} ([0-9]{8}).*"); //$NON-NLS-1$ Matcher matcher = pattern.matcher(strings[0]); if (matcher.matches()) { if (Integer.parseInt(matcher.group(1)) == 1) { mResult[0] = true; } } } } @Override public boolean isCancelled() { return false; } } public static ViewServerInfo loadViewServerInfo(IDevice device) { int server = -1; int protocol = -1; DeviceConnection connection = null; try { connection = new DeviceConnection(device); connection.sendCommand("SERVER"); //$NON-NLS-1$ String line = connection.getInputStream().readLine(); if (line != null) { server = Integer.parseInt(line); } } catch (Exception e) { Log.e(TAG, "Unable to get view server version from device " + device); } finally { if (connection != null) { connection.close(); } } connection = null; try { connection = new DeviceConnection(device); connection.sendCommand("PROTOCOL"); //$NON-NLS-1$ String line = connection.getInputStream().readLine(); if (line != null) { protocol = Integer.parseInt(line); } } catch (Exception e) { Log.e(TAG, "Unable to get view server protocol version from device " + device); } finally { if (connection != null) { connection.close(); } } if (server == -1 || protocol == -1) { return null; } ViewServerInfo returnValue = new ViewServerInfo(server, protocol); synchronized (sViewServerInfo) { sViewServerInfo.put(device, returnValue); } return returnValue; } public static ViewServerInfo getViewServerInfo(IDevice device) { synchronized (sViewServerInfo) { return sViewServerInfo.get(device); } } public static void removeViewServerInfo(IDevice device) { synchronized (sViewServerInfo) { sViewServerInfo.remove(device); } } /* * This loads the list of windows from the specified device. The format is: * hashCode1 title1 hashCode2 title2 ... hashCodeN titleN DONE. */ public static Window[] loadWindows(IDevice device) { ArrayList<Window> windows = new ArrayList<Window>(); DeviceConnection connection = null; ViewServerInfo serverInfo = getViewServerInfo(device); try { connection = new DeviceConnection(device); connection.sendCommand("LIST"); //$NON-NLS-1$ BufferedReader in = connection.getInputStream(); String line; while ((line = in.readLine()) != null) { if ("DONE.".equalsIgnoreCase(line)) { //$NON-NLS-1$ break; } int index = line.indexOf(' '); if (index != -1) { String windowId = line.substring(0, index); int id; if (serverInfo.serverVersion > 2) { id = (int) Long.parseLong(windowId, 16); } else { id = Integer.parseInt(windowId, 16); } Window w = new Window(device, line.substring(index + 1), id); windows.add(w); } } // Automatic refreshing of windows was added in protocol version 3. // Before, the user needed to specify explicitly that he wants to // get the focused window, which was done using a special type of // window with hash code -1. if (serverInfo.protocolVersion < 3) { windows.add(Window.getFocusedWindow(device)); } } catch (Exception e) { Log.e(TAG, "Unable to load the window list from device " + device); } finally { if (connection != null) { connection.close(); } } // The server returns the list of windows from the window at the bottom // to the top. We want the reverse order to put the top window on top of // the list. Window[] returnValue = new Window[windows.size()]; for (int i = windows.size() - 1; i >= 0; i--) { returnValue[returnValue.length - i - 1] = windows.get(i); } return returnValue; } /* * This gets the hash code of the window that has focus. Only works with * protocol version 3 and above. */ public static int getFocusedWindow(IDevice device) { DeviceConnection connection = null; try { connection = new DeviceConnection(device); connection.sendCommand("GET_FOCUS"); //$NON-NLS-1$ String line = connection.getInputStream().readLine(); if (line == null || line.length() == 0) { return -1; } return (int) Long.parseLong(line.substring(0, line.indexOf(' ')), 16); } catch (Exception e) { Log.e(TAG, "Unable to get the focused window from device " + device); } finally { if (connection != null) { connection.close(); } } return -1; } public static ViewNode loadWindowData(Window window) { DeviceConnection connection = null; try { connection = new DeviceConnection(window.getDevice()); connection.sendCommand("DUMP " + window.encode()); //$NON-NLS-1$ ViewNode currentNode = processDump(window, connection); return currentNode; } catch (Exception e) { Log.e(TAG, "Unable to load window data for window " + window.getTitle() + " on device " + window.getDevice()); } finally { if (connection != null) { connection.close(); } } return null; } public static ViewNode selectiveDump(Window window) { DeviceConnection connection = null; try { connection = new DeviceConnection(window.getDevice()); connection.sendCommand("DUMP_SELECTIVE " + window.encode()); //$NON-NLS-1$ ViewNode currentNode = processDump(window, connection); return currentNode; } catch (Exception e) { Log.e(TAG, "Unable to load window data for window " + window.getTitle() + " on device " + window.getDevice()); } finally { if (connection != null) { connection.close(); } } return null; } /** * @param window * @param connection * @return * @throws IOException */ private static ViewNode processDump(Window window, DeviceConnection connection) throws IOException { StringBuilder sb = new StringBuilder(); BufferedReader in = connection.getInputStream(); ViewNode currentNode = null; int currentDepth = -1; String line; while ((line = in.readLine()) != null) { sb.append(line); sb.append("\n"); if ("DONE.".equalsIgnoreCase(line)) { break; } int depth = 0; while (line.charAt(depth) == ' ') { depth++; } while (depth <= currentDepth) { currentNode = currentNode.parent; currentDepth--; } currentNode = new ViewNode(window, currentNode, line.substring(depth)); currentDepth = depth; } if (currentNode == null) { return null; } while (currentNode.parent != null) { currentNode = currentNode.parent; } ViewServerInfo serverInfo = getViewServerInfo(window.getDevice()); if (serverInfo != null) { currentNode.protocolVersion = serverInfo.protocolVersion; } // FileUtils.writeStringToFile(new File("dump.txt"), sb.toString()); return currentNode; } public static boolean loadProfileData(Window window, ViewNode viewNode) { DeviceConnection connection = null; try { connection = new DeviceConnection(window.getDevice()); connection.sendCommand("PROFILE " + window.encode() + " " + viewNode.toString()); //$NON-NLS-1$ BufferedReader in = connection.getInputStream(); int protocol; synchronized (sViewServerInfo) { protocol = sViewServerInfo.get(window.getDevice()).protocolVersion; } if (protocol < 3) { return loadProfileData(viewNode, in); } else { boolean ret = loadProfileDataRecursive(viewNode, in); if (ret) { viewNode.setProfileRatings(); } return ret; } } catch (Exception e) { Log.e(TAG, "Unable to load profiling data for window " + window.getTitle() + " on device " + window.getDevice()); } finally { if (connection != null) { connection.close(); } } return false; } private static boolean loadProfileData(ViewNode node, BufferedReader in) throws IOException { String line; if ((line = in.readLine()) == null || line.equalsIgnoreCase("-1 -1 -1") //$NON-NLS-1$ || line.equalsIgnoreCase("DONE.")) { //$NON-NLS-1$ return false; } String[] data = line.split(" "); node.measureTime = (Long.parseLong(data[0]) / 1000.0) / 1000.0; node.layoutTime = (Long.parseLong(data[1]) / 1000.0) / 1000.0; node.drawTime = (Long.parseLong(data[2]) / 1000.0) / 1000.0; return true; } private static boolean loadProfileDataRecursive(ViewNode node, BufferedReader in) throws IOException { if (!loadProfileData(node, in)) { return false; } for (int i = 0; i < node.children.size(); i++) { if (!loadProfileDataRecursive(node.children.get(i), in)) { return false; } } return true; } public static Image loadCapture(Window window, ViewNode viewNode) { DeviceConnection connection = null; try { connection = new DeviceConnection(window.getDevice()); connection.getSocket().setSoTimeout(5000); connection.sendCommand("CAPTURE " + window.encode() + " " + viewNode.toString()); //$NON-NLS-1$ return new Image(Display.getDefault(), connection.getSocket().getInputStream()); } catch (Exception e) { Log.e(TAG, "Unable to capture data for node " + viewNode + " in window " + window.getTitle() + " on device " + window.getDevice()); } finally { if (connection != null) { connection.close(); } } return null; } public static PsdFile captureLayers(Window window) { DeviceConnection connection = null; DataInputStream in = null; try { connection = new DeviceConnection(window.getDevice()); connection.sendCommand("CAPTURE_LAYERS " + window.encode()); //$NON-NLS-1$ in = new DataInputStream(new BufferedInputStream(connection.getSocket().getInputStream())); int width = in.readInt(); int height = in.readInt(); PsdFile psd = new PsdFile(width, height); while (readLayer(in, psd)) { } return psd; } catch (Exception e) { Log.e(TAG, "Unable to capture layers for window " + window.getTitle() + " on device " + window.getDevice()); } finally { if (in != null) { try { in.close(); } catch (Exception ex) { } } connection.close(); } return null; } private static boolean readLayer(DataInputStream in, PsdFile psd) { try { if (in.read() == 2) { return false; } String name = in.readUTF(); boolean visible = in.read() == 1; int x = in.readInt(); int y = in.readInt(); int dataSize = in.readInt(); byte[] data = new byte[dataSize]; int read = 0; while (read < dataSize) { read += in.read(data, read, dataSize - read); } ByteArrayInputStream arrayIn = new ByteArrayInputStream(data); BufferedImage chunk = ImageIO.read(arrayIn); // Ensure the image is in the right format BufferedImage image = new BufferedImage(chunk.getWidth(), chunk.getHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D g = image.createGraphics(); g.drawImage(chunk, null, 0, 0); g.dispose(); psd.addLayer(name, image, new Point(x, y), visible); return true; } catch (Exception e) { return false; } } public static void invalidateView(ViewNode viewNode) { DeviceConnection connection = null; try { connection = new DeviceConnection(viewNode.window.getDevice()); connection.sendCommand("INVALIDATE " + viewNode.window.encode() + " " + viewNode); //$NON-NLS-1$ } catch (Exception e) { Log.e(TAG, "Unable to invalidate view " + viewNode + " in window " + viewNode.window + " on device " + viewNode.window.getDevice()); } finally { connection.close(); } } public static void requestLayout(ViewNode viewNode) { DeviceConnection connection = null; try { connection = new DeviceConnection(viewNode.window.getDevice()); connection.sendCommand("REQUEST_LAYOUT " + viewNode.window.encode() + " " + viewNode); //$NON-NLS-1$ } catch (Exception e) { Log.e(TAG, "Unable to request layout for node " + viewNode + " in window " + viewNode.window + " on device " + viewNode.window.getDevice()); } finally { connection.close(); } } public static void outputDisplayList(ViewNode viewNode) { DeviceConnection connection = null; try { connection = new DeviceConnection(viewNode.window.getDevice()); connection.sendCommand("OUTPUT_DISPLAYLIST " + viewNode.window.encode() + " " + viewNode); //$NON-NLS-2$ } catch (Exception e) { Log.e(TAG, "Unable to dump displaylist for node " + viewNode + " in window " + viewNode.window + " on device " + viewNode.window.getDevice()); } finally { connection.close(); } } }