Java tutorial
/* * Copyright (C) 2011 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.ide.eclipse.gltrace; import com.android.ddmlib.AdbCommandRejectedException; import com.android.ddmlib.AndroidDebugBridge; import com.android.ddmlib.Client; import com.android.ddmlib.IDevice; import com.android.ddmlib.IDevice.DeviceUnixSocketNamespace; import com.android.ddmlib.IShellOutputReceiver; import com.android.ddmlib.ShellCommandUnresponsiveException; import com.android.ddmlib.TimeoutException; import com.android.ide.eclipse.gltrace.editors.GLFunctionTraceViewer; import com.google.common.io.Closeables; import com.google.common.util.concurrent.SimpleTimeLimiter; import org.eclipse.core.filesystem.EFS; import org.eclipse.core.filesystem.IFileStore; import org.eclipse.core.runtime.Path; import org.eclipse.jface.action.IAction; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.window.Window; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorReference; import org.eclipse.ui.IURIEditorInput; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.IWorkbenchWindowActionDelegate; import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.WorkbenchException; import org.eclipse.ui.ide.IDE; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.net.Socket; import java.util.concurrent.Callable; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class CollectTraceAction implements IWorkbenchWindowActionDelegate { /** Abstract Unix Domain Socket Name used by the gltrace device code. */ private static final String GLTRACE_UDS = "gltrace"; //$NON-NLS-1$ /** Local port that is forwarded to the device's {@link #GLTRACE_UDS} socket. */ private static final int LOCAL_FORWARDED_PORT = 6039; /** Activity name to use for a system activity that has already been launched. */ private static final String SYSTEM_APP = "system"; //$NON-NLS-1$ /** Time to wait for the application to launch (seconds) */ private static final int LAUNCH_TIMEOUT = 15; /** Time to wait for the application to die (seconds) */ private static final int KILL_TIMEOUT = 5; private static final int MIN_API_LEVEL = 16; @Override public void run(IAction action) { connectToDevice(); } @Override public void selectionChanged(IAction action, ISelection selection) { } @Override public void dispose() { } @Override public void init(IWorkbenchWindow window) { } private void connectToDevice() { Shell shell = Display.getDefault().getActiveShell(); GLTraceOptionsDialog dlg = new GLTraceOptionsDialog(shell); if (dlg.open() != Window.OK) { return; } TraceOptions traceOptions = dlg.getTraceOptions(); IDevice device = getDevice(traceOptions.device); String apiLevelString = device.getProperty(IDevice.PROP_BUILD_API_LEVEL); int apiLevel; try { apiLevel = Integer.parseInt(apiLevelString); } catch (NumberFormatException e) { apiLevel = MIN_API_LEVEL; } if (apiLevel < MIN_API_LEVEL) { MessageDialog.openError(shell, "GL Trace", String.format( "OpenGL Tracing is only supported on devices at API Level %1$d." + "The selected device '%2$s' provides API level %3$s.", MIN_API_LEVEL, traceOptions.device, apiLevelString)); return; } try { setupForwarding(device, LOCAL_FORWARDED_PORT); } catch (Exception e) { MessageDialog.openError(shell, "Setup GL Trace", "Error while setting up port forwarding: " + e.getMessage()); return; } try { if (!SYSTEM_APP.equals(traceOptions.appToTrace)) { startActivity(device, traceOptions.appToTrace, traceOptions.activityToTrace, traceOptions.isActivityNameFullyQualified); } } catch (Exception e) { MessageDialog.openError(shell, "Setup GL Trace", "Error while launching application: " + e.getMessage()); return; } // if everything went well, the app should now be waiting for the gl debugger // to connect startTracing(shell, traceOptions, LOCAL_FORWARDED_PORT); // once tracing is complete, remove port forwarding disablePortForwarding(device, LOCAL_FORWARDED_PORT); // and finally open the editor to view the file openInEditor(shell, traceOptions.traceDestination); } public static void openInEditor(Shell shell, String traceFilePath) { final IFileStore fileStore = EFS.getLocalFileSystem().getStore(new Path(traceFilePath)); if (!fileStore.fetchInfo().exists()) { return; } final IWorkbench workbench = PlatformUI.getWorkbench(); IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); if (window == null) { return; } IWorkbenchPage page = window.getActivePage(); if (page == null) { return; } try { workbench.showPerspective("com.android.ide.eclipse.gltrace.perspective", window); } catch (WorkbenchException e) { } // if there is a editor already open, then refresh its model GLFunctionTraceViewer viewer = getOpenTraceViewer(page, traceFilePath); if (viewer != null) { viewer.setInput(shell, traceFilePath); } // open the editor (if not open), or bring it to foreground if it is already open try { IDE.openEditorOnFileStore(page, fileStore); } catch (PartInitException e) { GlTracePlugin.getDefault().logMessage("Unexpected error while opening gltrace file in editor: " + e); return; } } /** * Returns the editor part that has the provided file path open. * @param page page containing editors * @param traceFilePath file that should be open in an editor * @return if given trace file is already open, then a reference to that editor part, * null otherwise */ private static GLFunctionTraceViewer getOpenTraceViewer(IWorkbenchPage page, String traceFilePath) { IEditorReference[] editorRefs = page.getEditorReferences(); for (IEditorReference ref : editorRefs) { String id = ref.getId(); if (!GLFunctionTraceViewer.ID.equals(id)) { continue; } IEditorInput input = null; try { input = ref.getEditorInput(); } catch (PartInitException e) { continue; } if (!(input instanceof IURIEditorInput)) { continue; } if (traceFilePath.equals(((IURIEditorInput) input).getURI().getPath())) { return (GLFunctionTraceViewer) ref.getEditor(true); } } return null; } @SuppressWarnings("resource") // Closeables.closeQuietly public static void startTracing(Shell shell, TraceOptions traceOptions, int port) { Socket socket = new Socket(); DataInputStream traceDataStream = null; DataOutputStream traceCommandsStream = null; try { socket.connect(new java.net.InetSocketAddress("127.0.0.1", port)); //$NON-NLS-1$ socket.setTcpNoDelay(true); traceDataStream = new DataInputStream(socket.getInputStream()); traceCommandsStream = new DataOutputStream(socket.getOutputStream()); } catch (IOException e) { MessageDialog.openError(shell, "OpenGL Trace", "Unable to connect to remote GL Trace Server: " + e.getMessage()); return; } // create channel to send trace commands to device TraceCommandWriter traceCommandWriter = new TraceCommandWriter(traceCommandsStream); try { traceCommandWriter.setTraceOptions(traceOptions.collectFbOnEglSwap, traceOptions.collectFbOnGlDraw, traceOptions.collectTextureData); } catch (IOException e) { MessageDialog.openError(shell, "OpenGL Trace", "Unexpected error while setting trace options: " + e.getMessage()); closeSocket(socket); return; } FileOutputStream fos = null; try { fos = new FileOutputStream(traceOptions.traceDestination, false); } catch (FileNotFoundException e) { // input path is valid, so this cannot occur } // create trace writer that writes to a trace file TraceFileWriter traceFileWriter = new TraceFileWriter(fos, traceDataStream); traceFileWriter.start(); GLTraceCollectorDialog dlg = new GLTraceCollectorDialog(shell, traceFileWriter, traceCommandWriter, traceOptions); dlg.open(); traceFileWriter.stopTracing(); traceCommandWriter.close(); closeSocket(socket); } private static void closeSocket(Socket socket) { try { socket.close(); } catch (IOException e) { // ignore error while closing socket } } private void startActivity(IDevice device, String appPackage, String activity, boolean isActivityNameFullyQualified) throws TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, IOException, InterruptedException { killApp(device, appPackage); // kill app if it is already running waitUntilAppKilled(device, appPackage, KILL_TIMEOUT); StringBuilder activityPath = new StringBuilder(appPackage); if (!activity.isEmpty()) { activityPath.append('/'); if (!isActivityNameFullyQualified) { activityPath.append('.'); } activityPath.append(activity); } String startAppCmd = String.format( "am start --opengl-trace %s -a android.intent.action.MAIN -c android.intent.category.LAUNCHER", //$NON-NLS-1$ activityPath.toString()); Semaphore launchCompletionSempahore = new Semaphore(0); StartActivityOutputReceiver receiver = new StartActivityOutputReceiver(launchCompletionSempahore); device.executeShellCommand(startAppCmd, receiver); // wait until shell finishes launch command launchCompletionSempahore.acquire(); // throw exception if there was an error during launch String output = receiver.getOutput(); if (output.contains("Error")) { //$NON-NLS-1$ throw new RuntimeException(output); } // wait until the app itself has been launched waitUntilAppLaunched(device, appPackage, LAUNCH_TIMEOUT); } private void killApp(IDevice device, String appName) { Client client = device.getClient(appName); if (client != null) { client.kill(); } } private void waitUntilAppLaunched(final IDevice device, final String appName, int timeout) { Callable<Boolean> c = new Callable<Boolean>() { @Override public Boolean call() throws Exception { Client client; do { client = device.getClient(appName); } while (client == null); return Boolean.TRUE; } }; try { new SimpleTimeLimiter().callWithTimeout(c, timeout, TimeUnit.SECONDS, true); } catch (Exception e) { throw new RuntimeException("Timed out waiting for application to launch."); } // once the app has launched, wait an additional couple of seconds // for it to start up try { Thread.sleep(2000); } catch (InterruptedException e) { // ignore } } private void waitUntilAppKilled(final IDevice device, final String appName, int timeout) { Callable<Boolean> c = new Callable<Boolean>() { @Override public Boolean call() throws Exception { Client client; while ((client = device.getClient(appName)) != null) { client.kill(); } return Boolean.TRUE; } }; try { new SimpleTimeLimiter().callWithTimeout(c, timeout, TimeUnit.SECONDS, true); } catch (Exception e) { throw new RuntimeException("Timed out waiting for running application to die."); } } public static void setupForwarding(IDevice device, int i) throws TimeoutException, AdbCommandRejectedException, IOException { device.createForward(i, GLTRACE_UDS, DeviceUnixSocketNamespace.ABSTRACT); } public static void disablePortForwarding(IDevice device, int port) { try { device.removeForward(port, GLTRACE_UDS, DeviceUnixSocketNamespace.ABSTRACT); } catch (Exception e) { // ignore exceptions; } } private IDevice getDevice(String deviceName) { IDevice[] devices = AndroidDebugBridge.getBridge().getDevices(); for (IDevice device : devices) { if (device.getName().equals(deviceName)) { return device; } } return null; } private static class StartActivityOutputReceiver implements IShellOutputReceiver { private Semaphore mSemaphore; private StringBuffer sb = new StringBuffer(300); public StartActivityOutputReceiver(Semaphore s) { mSemaphore = s; } @Override public void addOutput(byte[] data, int offset, int length) { String d = new String(data, offset, length); sb.append(d); } @Override public void flush() { mSemaphore.release(); } @Override public boolean isCancelled() { return false; } public String getOutput() { return sb.toString(); } } }