Merge "Support systrace in monitor."

6 files changed, 828 insertions, 3 deletions

diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/icons/systrace.png b/eclipse/plugins/com.android.ide.eclipse.ddms/icons/systrace.png
new file mode 100644
index 0000000..f663914
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/icons/systrace.png
diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/DdmsPlugin.java b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/DdmsPlugin.java
index 71639ec..fe8c709 100644
--- a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/DdmsPlugin.java
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/DdmsPlugin.java
@@ -464,7 +464,7 @@ public final class DdmsPlugin extends AbstractUIPlugin implements IDeviceChangeL
         return sAdbLocation;
     }
 
-    public static String getToolsFolder2() {
+    public static String getToolsFolder() {
         return sToolsFolder;
     }
 
@@ -505,6 +505,8 @@ public final class DdmsPlugin extends AbstractUIPlugin implements IDeviceChangeL
         sHprofConverter = hprofConverter.getAbsolutePath();
         DdmUiPreferences.setTraceviewLocation(traceview.getAbsolutePath());
 
+        sToolsFolder = traceview.getParent();
+
         return true;
     }
 
diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOptionsDialog.java b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOptionsDialog.java
new file mode 100644
index 0000000..fd26f76
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOptionsDialog.java
@@ -0,0 +1,425 @@
+package com.android.ide.eclipse.ddms.systrace;
+
+import org.eclipse.jface.dialogs.TitleAreaDialog;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.FileDialog;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Text;
+
+import java.io.File;
+
+public class SystraceOptionsDialog extends TitleAreaDialog {
+    private static final String TITLE = "Android System Trace";
+    private static final String DEFAULT_MESSAGE =
+            "Settings to use while capturing system level trace";
+    private static final String DEFAULT_TRACE_FNAME = "trace.html"; //$NON-NLS-1$
+
+    private Text mDestinationText;
+    private String mDestinationPath;
+    private Text mTraceDurationText;
+    private Text mTraceBufferSizeText;
+
+    private static String sSaveToFolder = System.getProperty("user.home"); //$NON-NLS-1$
+    private static String sTraceDuration = "";
+    private static String sTraceBufferSize = "";
+
+    private Button mTraceCpuFreqBtn;
+    private Button mTraceCpuIdleBtn;
+    private Button mTraceCpuLoadBtn;
+    private Button mTraceDiskIoBtn;
+    private Button mTraceKernelWorkqueuesBtn;
+    private Button mTraceCpuSchedulerBtn;
+
+    private static boolean sTraceCpuFreq;
+    private static boolean sTraceCpuIdle;
+    private static boolean sTraceCpuLoad;
+    private static boolean sTraceDiskIo;
+    private static boolean sTraceKernelWorkqueues;
+    private static boolean sTraceCpuScheduler;
+
+    private Button mGfxTagBtn;
+    private Button mInputTagBtn;
+    private Button mViewTagBtn;
+    private Button mWebViewTagBtn;
+    private Button mWmTagBtn;
+    private Button mAmTagBtn;
+    private Button mSyncTagBtn;
+    private Button mAudioTagBtn;
+    private Button mVideoTagBtn;
+    private Button mCameraTagBtn;
+
+    private static boolean sGfxTag;
+    private static boolean sInputTag;
+    private static boolean sViewTag;
+    private static boolean sWebViewTag;
+    private static boolean sWmTag;
+    private static boolean sAmTag;
+    private static boolean sSyncTag;
+    private static boolean sAudioTag;
+    private static boolean sVideoTag;
+    private static boolean sCameraTag;
+
+    private final SystraceOptions mOptions = new SystraceOptions();
+
+    public SystraceOptionsDialog(Shell parentShell) {
+        super(parentShell);
+    }
+
+    @Override
+    protected Control createDialogArea(Composite parent) {
+        setTitle(TITLE);
+        setMessage(DEFAULT_MESSAGE);
+
+        Composite c = new Composite(parent, SWT.BORDER);
+        c.setLayout(new GridLayout(3, false));
+        c.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+        Label l = new Label(c, SWT.NONE);
+        l.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
+        l.setText("Destination File: ");
+
+        mDestinationText = new Text(c, SWT.BORDER);
+        mDestinationText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
+        mDestinationText.setText(sSaveToFolder + File.separator + DEFAULT_TRACE_FNAME);
+
+        final Button browse = new Button(c, SWT.NONE);
+        browse.setText("Browse...");
+        browse.addSelectionListener(new SelectionAdapter() {
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                String path = openBrowseDialog(browse.getShell());
+                if (path != null) mDestinationText.setText(path);
+            }
+        });
+
+        Label lblTraceDurationseconds = new Label(c, SWT.NONE);
+        lblTraceDurationseconds.setLayoutData(
+                new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
+        lblTraceDurationseconds.setText("Trace duration (seconds): ");
+
+        mTraceDurationText = new Text(c, SWT.BORDER);
+        mTraceDurationText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));
+        mTraceDurationText.setText(sTraceDuration);
+
+        Label lblTraceBufferSize = new Label(c, SWT.NONE);
+        lblTraceBufferSize.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
+        lblTraceBufferSize.setText("Trace Buffer Size (kb): ");
+
+        mTraceBufferSizeText = new Text(c, SWT.BORDER);
+        mTraceBufferSizeText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));
+        mTraceBufferSizeText.setText(sTraceBufferSize);
+
+        Label separator = new Label(c, SWT.SEPARATOR | SWT.HORIZONTAL);
+        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
+        gd.horizontalSpan = 3;
+        separator.setLayoutData(gd);
+
+        Group grpTraceEvents = new Group(c, SWT.BORDER);
+        grpTraceEvents.setLayout(new GridLayout(3, false));
+        grpTraceEvents.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false, 2, 1));
+        grpTraceEvents.setText("Trace Events");
+
+        mTraceCpuFreqBtn = new Button(grpTraceEvents, SWT.CHECK);
+        mTraceCpuFreqBtn.setText("CPU Frequency Changes");
+        mTraceCpuFreqBtn.setSelection(sTraceCpuFreq);
+
+        mTraceCpuIdleBtn = new Button(grpTraceEvents, SWT.CHECK);
+        mTraceCpuIdleBtn.setText("CPU Idle Events");
+        mTraceCpuIdleBtn.setSelection(sTraceCpuIdle);
+
+        mTraceCpuLoadBtn = new Button(grpTraceEvents, SWT.CHECK);
+        mTraceCpuLoadBtn.setText("CPU Load");
+        mTraceCpuLoadBtn.setSelection(sTraceCpuLoad);
+
+        mTraceCpuSchedulerBtn = new Button(grpTraceEvents, SWT.CHECK);
+        mTraceCpuSchedulerBtn.setText("CPU Scheduler");
+        mTraceCpuSchedulerBtn.setSelection(sTraceCpuScheduler);
+
+        Group grpTraceRootEvents = new Group(c, SWT.BORDER);
+        grpTraceRootEvents.setLayout(new GridLayout(2, false));
+        grpTraceRootEvents.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false, 2, 1));
+        grpTraceRootEvents.setText("Trace Events that require root privileges on device");
+
+        mTraceDiskIoBtn = new Button(grpTraceRootEvents, SWT.CHECK);
+        mTraceDiskIoBtn.setText("Disk I/O");
+        mTraceDiskIoBtn.setSelection(sTraceDiskIo);
+
+        mTraceKernelWorkqueuesBtn = new Button(grpTraceRootEvents, SWT.CHECK);
+        mTraceKernelWorkqueuesBtn.setText("Kernel Workqueues (requires root)");
+        mTraceKernelWorkqueuesBtn.setSelection(sTraceKernelWorkqueues);
+
+        Group grpTraceTags = new Group(c, SWT.BORDER);
+        grpTraceTags.setLayout(new GridLayout(5, false));
+        grpTraceTags.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false, 3, 1));
+        grpTraceTags.setText("Trace Tags");
+
+        mGfxTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mGfxTagBtn.setText("gfx");
+        mGfxTagBtn.setSelection(sGfxTag);
+
+        mInputTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mInputTagBtn.setText("input");
+        mInputTagBtn.setSelection(sInputTag);
+
+        mViewTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mViewTagBtn.setText("view");
+        mViewTagBtn.setSelection(sViewTag);
+
+        mWebViewTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mWebViewTagBtn.setText("webview");
+        mWebViewTagBtn.setSelection(sWebViewTag);
+
+        mWmTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mWmTagBtn.setText("wm");
+        mWmTagBtn.setSelection(sWmTag);
+
+        mAmTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mAmTagBtn.setText("am");
+        mAmTagBtn.setSelection(sAmTag);
+
+        mSyncTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mSyncTagBtn.setText("sync");
+        mSyncTagBtn.setSelection(sSyncTag);
+
+        mAudioTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mAudioTagBtn.setText("audio");
+        mAudioTagBtn.setSelection(sAudioTag);
+
+        mVideoTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mVideoTagBtn.setText("video");
+        mVideoTagBtn.setSelection(sVideoTag);
+
+        mCameraTagBtn = new Button(grpTraceTags, SWT.CHECK);
+        mCameraTagBtn.setText("camera");
+        mCameraTagBtn.setSelection(sCameraTag);
+
+        Label lblTraceTagsWarning = new Label(grpTraceTags, SWT.NONE);
+        lblTraceTagsWarning.setText(
+                "Changes to trace tags will likely need a restart of the Android framework to take effect:\n"
+                + "    $ adb shell stop\n"
+                + "    $ adb shell start");
+        lblTraceTagsWarning.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false, 5, 1));
+
+        ModifyListener m = new ModifyListener() {
+            @Override
+            public void modifyText(ModifyEvent e) {
+                validateFields();
+            }
+        };
+
+        mDestinationText.addModifyListener(m);
+        mTraceBufferSizeText.addModifyListener(m);
+        mTraceDurationText.addModifyListener(m);
+
+        return c;
+    }
+
+    private void validateFields() {
+        // validate trace destination path
+        String msg = validatePath(mDestinationText.getText());
+        if (msg != null) {
+            setErrorMessage(msg);
+            getButton(OK).setEnabled(false);
+            return;
+        }
+
+        // validate the trace duration
+        if (!validateInteger(mTraceDurationText.getText())) {
+            setErrorMessage("Trace Duration should be a valid integer (seconds)");
+            getButton(OK).setEnabled(false);
+            return;
+        }
+
+        // validate the trace buffer size
+        if (!validateInteger(mTraceBufferSizeText.getText())) {
+            setErrorMessage("Trace Buffer Size should be a valid integer (kilobytes)");
+            getButton(OK).setEnabled(false);
+            return;
+        }
+
+        getButton(OK).setEnabled(true);
+        setErrorMessage(null);
+    }
+
+    private boolean validateInteger(String text) {
+        if (text == null || text.isEmpty()) {
+            return true;
+        }
+
+        try {
+            Integer.parseInt(text);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    private String validatePath(String path) {
+        if (path == null || path.isEmpty()) {
+            return null;
+        }
+
+        File f = new File(path);
+        if (f.isDirectory()) {
+            return String.format("The path '%s' points to a folder", path);
+        }
+
+        if (!f.exists()) { // if such a file doesn't exist, make sure the parent folder is valid
+            if (!f.getParentFile().isDirectory()) {
+                return String.format("That path '%s' is not a valid folder.", f.getParent());
+            }
+        }
+
+        return null;
+    }
+
+    private String openBrowseDialog(Shell parentShell) {
+        FileDialog fd = new FileDialog(parentShell, SWT.SAVE);
+
+        fd.setText("Save To");
+        fd.setFileName(DEFAULT_TRACE_FNAME);
+
+        fd.setFilterPath(sSaveToFolder);
+        fd.setFilterExtensions(new String[] { "*.html" }); //$NON-NLS-1$
+
+        String fname = fd.open();
+        if (fname == null || fname.trim().length() == 0) {
+            return null;
+        }
+
+        sSaveToFolder = fd.getFilterPath();
+        return fname;
+    }
+
+    @Override
+    protected void okPressed() {
+        mDestinationPath = mDestinationText.getText().trim();
+
+        sTraceDuration = mTraceDurationText.getText();
+        if (!sTraceDuration.isEmpty()) {
+            mOptions.mTraceDuration = Integer.parseInt(sTraceDuration);
+        }
+
+        sTraceBufferSize = mTraceBufferSizeText.getText();
+        if (!sTraceBufferSize.isEmpty()) {
+            mOptions.mTraceBufferSize = Integer.parseInt(sTraceBufferSize);
+        }
+
+        mOptions.mTraceCpuFreq = mTraceCpuFreqBtn.getSelection();
+        mOptions.mTraceCpuIdle = mTraceCpuIdleBtn.getSelection();
+        mOptions.mTraceCpuLoad = mTraceCpuLoadBtn.getSelection();
+        mOptions.mTraceDiskIo = mTraceDiskIoBtn.getSelection();
+        mOptions.mTraceKernelWorkqueues = mTraceKernelWorkqueuesBtn.getSelection();
+        mOptions.mTraceCpuScheduler = mTraceCpuSchedulerBtn.getSelection();
+
+        if (mGfxTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_GFX);
+        if (mInputTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_INPUT);
+        if (mViewTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_VIEW);
+        if (mWebViewTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_WEBVIEW);
+        if (mWmTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_WM);
+        if (mAmTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_AM);
+        if (mSyncTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_SYNC);
+        if (mAudioTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_AUDIO);
+        if (mViewTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_VIDEO);
+        if (mCameraTagBtn.getSelection()) mOptions.enableTag(SystraceOptions.TAG_CAMERA);
+
+        // save current selections to be restored if the dialog is invoked again
+        sTraceCpuFreq = mTraceCpuFreqBtn.getSelection();
+        sTraceCpuIdle = mTraceCpuIdleBtn.getSelection();
+        sTraceCpuLoad = mTraceCpuLoadBtn.getSelection();
+        sTraceDiskIo = mTraceDiskIoBtn.getSelection();
+        sTraceKernelWorkqueues = mTraceKernelWorkqueuesBtn.getSelection();
+        sTraceCpuScheduler = mTraceCpuSchedulerBtn.getSelection();
+
+        sGfxTag = mGfxTagBtn.getSelection();
+        sInputTag = mInputTagBtn.getSelection();
+        sViewTag = mViewTagBtn.getSelection();
+        sWebViewTag = mWebViewTagBtn.getSelection();
+        sWmTag = mWmTagBtn.getSelection();
+        sAmTag = mAmTagBtn.getSelection();
+        sSyncTag = mSyncTagBtn.getSelection();
+        sAudioTag = mAudioTagBtn.getSelection();
+        sViewTag = mViewTagBtn.getSelection();
+        sCameraTag = mCameraTagBtn.getSelection();
+
+        super.okPressed();
+    }
+
+    public SystraceOptions getSystraceOptions() {
+        return mOptions;
+    }
+
+    public String getTraceFilePath() {
+        return mDestinationPath;
+    }
+
+    public class SystraceOptions {
+        // This list is based on the tags in frameworks/native/include/utils/Trace.h
+        private static final int TAG_GFX = 1 << 1;
+        private static final int TAG_INPUT = 1 << 2;
+        private static final int TAG_VIEW = 1 << 3;
+        private static final int TAG_WEBVIEW = 1 << 4;
+        private static final int TAG_WM = 1 << 5;
+        private static final int TAG_AM = 1 << 6;
+        private static final int TAG_SYNC = 1 << 7;
+        private static final int TAG_AUDIO = 1 << 8;
+        private static final int TAG_VIDEO = 1 << 9;
+        private static final int TAG_CAMERA = 1 << 10;
+
+        private int mTraceBufferSize;
+        private int mTraceDuration;
+
+        private boolean mTraceCpuFreq;
+        private boolean mTraceCpuIdle;
+        private boolean mTraceCpuLoad;
+        private boolean mTraceDiskIo;
+        private boolean mTraceKernelWorkqueues;
+        private boolean mTraceCpuScheduler;
+
+        private int mTag;
+
+        private void enableTag(int tag) {
+            mTag |= tag;
+        }
+
+        public String getTraceTag() {
+            return mTag == 0 ? null : Integer.toHexString(mTag);
+        }
+
+        public String getCommandLineOptions() {
+            StringBuilder sb = new StringBuilder(20);
+
+            if (mTraceCpuFreq) sb.append("-f "); //$NON-NLS-1$
+            if (mTraceCpuIdle) sb.append("-i "); //$NON-NLS-1$
+            if (mTraceCpuLoad) sb.append("-l "); //$NON-NLS-1$
+            if (mTraceDiskIo) sb.append("-d ");  //$NON-NLS-1$
+            if (mTraceKernelWorkqueues) sb.append("-w "); //$NON-NLS-1$
+            if (mTraceCpuScheduler) sb.append("-s "); //$NON-NLS-1$
+
+            if (mTraceDuration > 0) {
+                sb.append("-t");    //$NON-NLS-1$
+                sb.append(mTraceDuration);
+                sb.append(' ');
+            }
+
+            if (mTraceBufferSize > 0) {
+                sb.append("-b ");	//$NON-NLS-1$
+                sb.append(mTraceBufferSize);
+                sb.append(' ');
+            }
+
+            return sb.toString().trim();
+        }
+    }
+}
diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOutputParser.java b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOutputParser.java
new file mode 100644
index 0000000..19e8471
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceOutputParser.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2012 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.ddms.systrace;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.Files;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+
+/** {@link SystraceOutputParser} receives the output of atrace command run on the device,
+ * parses it and generates html based on the trace */
+public class SystraceOutputParser {
+    private static final String TRACE_START = "TRACE:\n"; //$NON-NLS-1$
+
+    private static final String HTML_PREFIX = "<!DOCTYPE HTML>\n"
+            + "<html>\n"
+            + "<head i18n-values=\"dir:textdirection;\">\n"
+            + "<title>Android System Trace</title>\n"
+            + "%s\n"
+            + "%s\n"
+            + "<style>\n"
+            + "  .view {\n"
+            + "    overflow: hidden;\n"
+            + "    position: absolute;\n"
+            + "    top: 0;\n"
+            + "    bottom: 0;\n"
+            + "    left: 0;\n"
+            + "    right: 0;\n"
+            + "  }\n"
+            + "</style>\n"
+            + "</head>\n"
+            + "<body>\n"
+            + "  <div class=\"view\">\n"
+            + "  </div>\n"
+            + "  <script>\n"
+            + "  var linuxPerfData = \"\\\n";
+
+    private static final String HTML_SUFFIX =
+              "           dummy-0000  [000] 0.0: 0: trace_event_clock_sync: parent_ts=0.0\\n\";\n"
+            + "  </script>\n"
+            + "</body>\n"
+            + "</html>\n";
+
+    private final boolean mUncompress;
+    private final String mJs;
+    private final String mCss;
+
+    private byte[] mAtraceOutput;
+    private int mAtraceLength;
+    private int mSystraceIndex = -1;
+
+    /**
+     * Constructs a atrace output parser.
+     * @param compressedStream Is the input stream compressed using zlib?
+     * @param systraceJs systrace javascript content
+     * @param systraceCss systrace css content
+     */
+    public SystraceOutputParser(boolean compressedStream, String systraceJs, String systraceCss) {
+        mUncompress = compressedStream;
+        mJs = systraceJs;
+        mCss = systraceCss;
+    }
+
+    /**
+     * Parses the atrace output for systrace content.
+     * @param atraceOutput output bytes from atrace
+     */
+    public void parse(byte[] atraceOutput) {
+        mAtraceOutput = atraceOutput;
+        mAtraceLength = atraceOutput.length;
+
+        removeCrLf();
+
+        // locate the trace start marker within the first hundred bytes
+        String header = new String(mAtraceOutput, 0, Math.min(100, mAtraceLength));
+        mSystraceIndex = locateSystraceData(header);
+
+        if (mSystraceIndex < 0) {
+            throw new RuntimeException("Unable to find trace start marker 'TRACE:':\n" + header);
+        }
+    }
+
+    /** Replaces \r\n with \n in {@link #mAtraceOutput}. */
+    private void removeCrLf() {
+        int dst = 0;
+        for (int src = 0; src < mAtraceLength - 1; src++, dst++) {
+            byte copy;
+            if (mAtraceOutput[src] == '\r' && mAtraceOutput[src + 1] == '\n') {
+                copy = '\n';
+                src++;
+            } else {
+                copy = mAtraceOutput[src];
+            }
+            mAtraceOutput[dst] = copy;
+        }
+
+        mAtraceLength = dst;
+    }
+
+    private int locateSystraceData(String header) {
+        int index = header.indexOf(TRACE_START);
+        if (index < 0) {
+            return -1;
+        } else {
+            return index + TRACE_START.length();
+        }
+    }
+
+    public String getSystraceHtml() {
+        if (mSystraceIndex < 0) {
+            return "";
+        }
+
+        String trace = "";
+        if (mUncompress) {
+            Inflater decompressor = new Inflater();
+            decompressor.setInput(mAtraceOutput, mSystraceIndex, mAtraceLength - mSystraceIndex);
+
+            byte[] buf = new byte[4096];
+            int n;
+            StringBuilder sb = new StringBuilder(1000);
+            try {
+                while ((n = decompressor.inflate(buf)) > 0) {
+                    sb.append(new String(buf, 0, n));
+                }
+            } catch (DataFormatException e) {
+                throw new RuntimeException(e);
+            }
+            decompressor.end();
+
+            trace = sb.toString();
+        } else {
+            trace = new String(mAtraceOutput, mSystraceIndex, mAtraceLength - mSystraceIndex);
+        }
+
+        // each line should end with the characters \n\ followed by a newline
+        String html_out = trace.replaceAll("\n", "\\\\n\\\\\n");
+        String header = String.format(HTML_PREFIX, mCss, mJs);
+        String footer = HTML_SUFFIX;
+        return header + html_out + footer;
+    }
+
+    public static String getJs(File assetsFolder) {
+        try {
+            return String.format("<script language=\"javascript\">%s</script>",
+                    Files.toString(new File(assetsFolder, "script.js"), Charsets.UTF_8));
+        } catch (IOException e) {
+            return "";
+        }
+    }
+
+    public static String getCss(File assetsFolder) {
+        try {
+            return String.format("<style type=\"text/css\">%s</style>",
+                    Files.toString(new File(assetsFolder, "style.css"), Charsets.UTF_8));
+        } catch (IOException e) {
+            return "";
+        }
+    }
+}
diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceTask.java b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceTask.java
new file mode 100644
index 0000000..7262964
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/systrace/SystraceTask.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012 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.ddms.systrace;
+
+import com.android.ddmlib.IDevice;
+import com.android.ddmlib.IShellOutputReceiver;
+import com.google.common.primitives.Bytes;
+
+public class SystraceTask implements Runnable {
+    private final IDevice mDevice;
+    private final String mOptions;
+
+    private volatile boolean mCancel;
+
+    private final Object mLock = new Object();
+    private String errorMessage;
+    private boolean mTraceComplete;
+    private byte[] mBuffer = new byte[1024];
+    private int mDataLength = 0;
+
+    public SystraceTask(IDevice device, String options) {
+        mDevice = device;
+        mOptions = options;
+    }
+
+    @Override
+    public void run() {
+        try {
+            mDevice.executeShellCommand("atrace " + mOptions, new Receiver(), 0);
+        } catch (Exception e) {
+            synchronized (mLock) {
+                errorMessage = "Unexpected error while running atrace on device: " + e;
+            }
+        }
+    }
+
+    public void cancel() {
+        mCancel = true;
+    }
+
+    public String getError() {
+        synchronized (mLock) {
+            return errorMessage;
+        }
+    }
+
+    public byte[] getAtraceOutput() {
+        synchronized (mLock) {
+            return mTraceComplete ? mBuffer : null;
+        }
+    }
+
+    private class Receiver implements IShellOutputReceiver {
+        @Override
+        public void addOutput(byte[] data, int offset, int length) {
+            synchronized (mLock) {
+                if (mDataLength + length > mBuffer.length) {
+                    mBuffer = Bytes.ensureCapacity(mBuffer, mDataLength + length + 1, 1024);
+                }
+
+                for (int i = 0; i < length; i++) {
+                    mBuffer[mDataLength + i] = data[offset + i];
+                }
+                mDataLength += length;
+            }
+        }
+
+        @Override
+        public void flush() {
+            synchronized (mLock) {
+                // trim mBuffer to its final size
+                byte[] copy = new byte[mDataLength];
+                for (int i = 0; i < mDataLength; i++) {
+                    copy[i] = mBuffer[i];
+                }
+                mBuffer = copy;
+
+                mTraceComplete = true;
+            }
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return mCancel;
+        }
+    }
+}
diff --git a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/views/DeviceView.java b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/views/DeviceView.java
index 17670e4..ae9ab91 100644
--- a/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/views/DeviceView.java
+++ b/eclipse/plugins/com.android.ide.eclipse.ddms/src/com/android/ide/eclipse/ddms/views/DeviceView.java
@@ -22,6 +22,7 @@ import com.android.ddmlib.Client;
 import com.android.ddmlib.ClientData;
 import com.android.ddmlib.ClientData.IHprofDumpHandler;
 import com.android.ddmlib.ClientData.MethodProfilingStatus;
+import com.android.ddmlib.CollectingOutputReceiver;
 import com.android.ddmlib.DdmPreferences;
 import com.android.ddmlib.IDevice;
 import com.android.ddmlib.SyncException;
@@ -41,9 +42,14 @@ import com.android.ide.eclipse.ddms.IDebuggerConnector;
 import com.android.ide.eclipse.ddms.editors.UiAutomatorViewer;
 import com.android.ide.eclipse.ddms.i18n.Messages;
 import com.android.ide.eclipse.ddms.preferences.PreferenceInitializer;
+import com.android.ide.eclipse.ddms.systrace.SystraceOptionsDialog;
+import com.android.ide.eclipse.ddms.systrace.SystraceOptionsDialog.SystraceOptions;
+import com.android.ide.eclipse.ddms.systrace.SystraceOutputParser;
+import com.android.ide.eclipse.ddms.systrace.SystraceTask;
 import com.android.uiautomator.UiAutomatorHelper;
 import com.android.uiautomator.UiAutomatorHelper.UiAutomatorException;
 import com.android.uiautomator.UiAutomatorHelper.UiAutomatorResult;
+import com.google.common.io.Files;
 
 import org.eclipse.core.filesystem.EFS;
 import org.eclipse.core.filesystem.IFileStore;
@@ -80,6 +86,8 @@ import org.eclipse.ui.part.ViewPart;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 public class DeviceView extends ViewPart implements IUiSelectionListener, IClientChangeListener {
 
@@ -95,6 +103,7 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
     private Action mResetAdbAction;
     private Action mCaptureAction;
     private Action mViewUiAutomatorHierarchyAction;
+    private Action mSystraceAction;
     private Action mUpdateThreadAction;
     private Action mUpdateHeapAction;
     private Action mGcAction;
@@ -331,6 +340,18 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
         mViewUiAutomatorHierarchyAction.setImageDescriptor(
                 DdmsPlugin.getImageDescriptor("icons/uiautomator.png")); //$NON-NLS-1$
 
+        mSystraceAction = new Action("Capture System Wide Trace") {
+            @Override
+            public void run() {
+                launchSystrace(mDeviceList.getSelectedDevice(),
+                        DdmsPlugin.getDisplay().getActiveShell());
+            }
+        };
+        mSystraceAction.setToolTipText("Capture system wide trace using Android systrace");
+        mSystraceAction.setImageDescriptor(
+                DdmsPlugin.getImageDescriptor("icons/systrace.png")); //$NON-NLS-1$
+        mSystraceAction.setEnabled(true);
+
         mResetAdbAction = new Action(Messages.DeviceView_Reset_ADB) {
             @Override
             public void run() {
@@ -536,6 +557,98 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
         }
     };
 
+    private void launchSystrace(final IDevice device, final Shell parentShell) {
+        final SystraceOptionsDialog dlg = new SystraceOptionsDialog(parentShell);
+        if (dlg.open() != SystraceOptionsDialog.OK) {
+            return;
+        }
+
+        final SystraceOptions options = dlg.getSystraceOptions();
+
+        // set trace tag if necessary:
+        //      adb shell setprop debug.atrace.tags.enableflags <tag>
+        String tag = options.getTraceTag();
+        if (tag != null) {
+            CountDownLatch setTagLatch = new CountDownLatch(1);
+            CollectingOutputReceiver receiver = new CollectingOutputReceiver(setTagLatch);
+            try {
+                String cmd = "setprop debug.atrace.tags.enableflags " + tag;
+                device.executeShellCommand(cmd, receiver);
+                setTagLatch.await(5, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                MessageDialog.openError(parentShell,
+                        "Systrace",
+                        "Unexpected error while setting trace tags: " + e);
+                return;
+            }
+
+            String shellOutput = receiver.getOutput();
+            if (shellOutput.contains("Error type")) {                   //$NON-NLS-1$
+                throw new RuntimeException(receiver.getOutput());
+            }
+        }
+
+        // obtain the output of "adb shell atrace <trace-options>" and generate the html file
+        ProgressMonitorDialog d = new ProgressMonitorDialog(parentShell);
+        try {
+            d.run(true, true, new IRunnableWithProgress() {
+                @Override
+                public void run(IProgressMonitor monitor) throws InvocationTargetException,
+                        InterruptedException {
+                    boolean COMPRESS_DATA = true;
+
+                    monitor.setTaskName("Collecting Trace Information");
+                    final String atraceOptions = options.getCommandLineOptions()
+                                                + (COMPRESS_DATA ? " -z" : "");
+                    SystraceTask task = new SystraceTask(device, atraceOptions);
+                    Thread t = new Thread(task, "Systrace Output Receiver");
+                    t.start();
+
+                    // check if the user has cancelled tracing every so often
+                    while (true) {
+                        t.join(1000);
+
+                        if (t.isAlive()) {
+                            if (monitor.isCanceled()) {
+                                task.cancel();
+                                return;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+
+                    if (task.getError() != null) {
+                        throw new RuntimeException(task.getError());
+                    }
+
+                    monitor.setTaskName("Saving trace information");
+                    File systraceAssets = new File(DdmsPlugin.getToolsFolder(), "systrace"); //$NON-NLS-1$
+                    SystraceOutputParser parser = new SystraceOutputParser(
+                            COMPRESS_DATA,
+                            SystraceOutputParser.getJs(systraceAssets),
+                            SystraceOutputParser.getCss(systraceAssets));
+
+                    parser.parse(task.getAtraceOutput());
+
+                    String html = parser.getSystraceHtml();
+                    try {
+                        Files.write(html.getBytes(), new File(dlg.getTraceFilePath()));
+                    } catch (IOException e) {
+                        throw new InvocationTargetException(e);
+                    }
+                }
+            });
+        } catch (InvocationTargetException e) {
+            ErrorDialog.openError(parentShell, "Systrace",
+                    "Unable to collect system trace.",
+                    new Status(Status.ERROR,
+                            DdmsPlugin.PLUGIN_ID,
+                            "Unexpected error while collecting system trace.",
+                            e.getCause()));
+        } catch (InterruptedException ignore) {
+        }
+    }
 
     @Override
     public void setFocus() {
@@ -635,8 +748,11 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
     }
 
     private void doSelectionChanged(IDevice selectedDevice) {
-        mCaptureAction.setEnabled(selectedDevice != null);
-        mViewUiAutomatorHierarchyAction.setEnabled(selectedDevice != null);
+        boolean validDevice = selectedDevice != null;
+
+        mCaptureAction.setEnabled(validDevice);
+        mViewUiAutomatorHierarchyAction.setEnabled(validDevice);
+        mSystraceAction.setEnabled(validDevice);
     }
 
     /**
@@ -663,6 +779,8 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
         menuManager.add(new Separator());
         menuManager.add(mViewUiAutomatorHierarchyAction);
         menuManager.add(new Separator());
+        menuManager.add(mSystraceAction);
+        menuManager.add(new Separator());
         menuManager.add(mResetAdbAction);
 
         // and then in the toolbar
@@ -682,6 +800,8 @@ public class DeviceView extends ViewPart implements IUiSelectionListener, IClien
         toolBarManager.add(mCaptureAction);
         toolBarManager.add(new Separator());
         toolBarManager.add(mViewUiAutomatorHierarchyAction);
+        toolBarManager.add(new Separator());
+        toolBarManager.add(mSystraceAction);
     }
 
     @Override