| /* |
| * Copyright (C) 2008 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.views; |
| |
| import com.android.ddmlib.AndroidDebugBridge; |
| import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener; |
| 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; |
| import com.android.ddmlib.SyncService; |
| import com.android.ddmlib.SyncService.ISyncProgressMonitor; |
| import com.android.ddmlib.TimeoutException; |
| import com.android.ddmuilib.DevicePanel; |
| import com.android.ddmuilib.DevicePanel.IUiSelectionListener; |
| import com.android.ddmuilib.ImageLoader; |
| import com.android.ddmuilib.ScreenShotDialog; |
| import com.android.ddmuilib.SyncProgressHelper; |
| import com.android.ddmuilib.SyncProgressHelper.SyncRunnable; |
| import com.android.ddmuilib.handler.BaseFileHandler; |
| import com.android.ddmuilib.handler.MethodProfilingHandler; |
| import com.android.ide.eclipse.ddms.DdmsPlugin; |
| import com.android.ide.eclipse.ddms.IClientAction; |
| 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.ISystraceOptions; |
| import com.android.ide.eclipse.ddms.systrace.ISystraceOptionsDialog; |
| import com.android.ide.eclipse.ddms.systrace.SystraceOptionsDialogV1; |
| import com.android.ide.eclipse.ddms.systrace.SystraceOptionsDialogV2; |
| import com.android.ide.eclipse.ddms.systrace.SystraceOutputParser; |
| import com.android.ide.eclipse.ddms.systrace.SystraceTask; |
| import com.android.ide.eclipse.ddms.systrace.SystraceVersionDetector; |
| 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; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.WorkbenchException; |
| import org.eclipse.ui.ide.IDE; |
| import org.eclipse.ui.part.ViewPart; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| public class DeviceView extends ViewPart implements IUiSelectionListener, IClientChangeListener { |
| |
| private final static boolean USE_SELECTED_DEBUG_PORT = true; |
| |
| public static final String ID = "com.android.ide.eclipse.ddms.views.DeviceView"; //$NON-NLS-1$ |
| |
| private static DeviceView sThis; |
| |
| private Shell mParentShell; |
| private DevicePanel mDeviceList; |
| |
| private Action mResetAdbAction; |
| private Action mCaptureAction; |
| private Action mViewUiAutomatorHierarchyAction; |
| private Action mSystraceAction; |
| private Action mUpdateThreadAction; |
| private Action mUpdateHeapAction; |
| private Action mGcAction; |
| private Action mKillAppAction; |
| private Action mDebugAction; |
| private Action mHprofAction; |
| private Action mTracingAction; |
| |
| private ImageDescriptor mTracingStartImage; |
| private ImageDescriptor mTracingStopImage; |
| |
| public class HProfHandler extends BaseFileHandler implements IHprofDumpHandler { |
| public final static String ACTION_SAVE = "hprof.save"; //$NON-NLS-1$ |
| public final static String ACTION_OPEN = "hprof.open"; //$NON-NLS-1$ |
| |
| public final static String DOT_HPROF = ".hprof"; //$NON-NLS-1$ |
| |
| HProfHandler(Shell parentShell) { |
| super(parentShell); |
| } |
| |
| @Override |
| protected String getDialogTitle() { |
| return Messages.DeviceView_HPROF_Error; |
| } |
| |
| @Override |
| public void onEndFailure(final Client client, final String message) { |
| mParentShell.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| displayErrorFromUiThread( |
| Messages.DeviceView_Unable_Create_HPROF_For_Application, |
| client.getClientData().getClientDescription(), |
| message != null ? message + "\n\n" : ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } finally { |
| // this will make sure the dump hprof button is |
| // re-enabled for the |
| // current selection. as the client is finished dumping |
| // an hprof file |
| doSelectionChanged(mDeviceList.getSelectedClient()); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void onSuccess(final String remoteFilePath, final Client client) { |
| mParentShell.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| final IDevice device = client.getDevice(); |
| try { |
| // get the sync service to pull the HPROF file |
| final SyncService sync = client.getDevice().getSyncService(); |
| if (sync != null) { |
| // get from the preference what action to take |
| IPreferenceStore store = DdmsPlugin.getDefault().getPreferenceStore(); |
| String value = store.getString(PreferenceInitializer.ATTR_HPROF_ACTION); |
| |
| if (ACTION_OPEN.equals(value)) { |
| File temp = File.createTempFile("android", DOT_HPROF); //$NON-NLS-1$ |
| final String tempPath = temp.getAbsolutePath(); |
| SyncProgressHelper.run(new SyncRunnable() { |
| |
| @Override |
| public void run(ISyncProgressMonitor monitor) |
| throws SyncException, IOException, |
| TimeoutException { |
| sync.pullFile(remoteFilePath, tempPath, monitor); |
| } |
| |
| @Override |
| public void close() { |
| sync.close(); |
| } |
| }, |
| String.format(Messages.DeviceView_Pulling_From_Device, |
| remoteFilePath), |
| mParentShell); |
| |
| open(tempPath); |
| } else { |
| // default action is ACTION_SAVE |
| promptAndPull(sync, |
| client.getClientData().getClientDescription() + DOT_HPROF, |
| remoteFilePath, Messages.DeviceView_Save_HPROF_File); |
| |
| } |
| } else { |
| displayErrorFromUiThread( |
| Messages.DeviceView_Unable_Download_HPROF_From_Device_One_Param_First_Message, |
| device.getSerialNumber()); |
| } |
| } catch (SyncException e) { |
| if (e.wasCanceled() == false) { |
| displayErrorFromUiThread( |
| Messages.DeviceView_Unable_Download_HPROF_From_Device_Two_Param, |
| device.getSerialNumber(), e.getMessage()); |
| } |
| } catch (Exception e) { |
| displayErrorFromUiThread( |
| Messages.DeviceView_Unable_Download_HPROF_From_Device_One_Param_Second_Message, |
| device.getSerialNumber()); |
| |
| } finally { |
| // this will make sure the dump hprof button is |
| // re-enabled for the |
| // current selection. as the client is finished dumping |
| // an hprof file |
| doSelectionChanged(mDeviceList.getSelectedClient()); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void onSuccess(final byte[] data, final Client client) { |
| mParentShell.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| // get from the preference what action to take |
| IPreferenceStore store = DdmsPlugin.getDefault().getPreferenceStore(); |
| String value = store.getString(PreferenceInitializer.ATTR_HPROF_ACTION); |
| |
| if (ACTION_OPEN.equals(value)) { |
| try { |
| // no need to give an extension since we're going to |
| // convert the |
| // file anyway after. |
| File tempFile = saveTempFile(data, null /* extension */); |
| open(tempFile.getAbsolutePath()); |
| } catch (Exception e) { |
| String errorMsg = e.getMessage(); |
| displayErrorFromUiThread( |
| Messages.DeviceView_Failed_To_Save_HPROF_Data, |
| errorMsg != null ? ":\n" + errorMsg : "."); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } else { |
| // default action is ACTION_SAVE |
| promptAndSave(client.getClientData().getClientDescription() + DOT_HPROF, |
| data, Messages.DeviceView_Save_HPROF_File); |
| } |
| } |
| }); |
| } |
| |
| private void open(String path) throws IOException, InterruptedException, PartInitException { |
| // make a temp file to convert the hprof into something |
| // readable by normal tools |
| File temp = File.createTempFile("android", DOT_HPROF); //$NON-NLS-1$ |
| String tempPath = temp.getAbsolutePath(); |
| |
| String[] command = new String[3]; |
| command[0] = DdmsPlugin.getHprofConverter(); |
| command[1] = path; |
| command[2] = tempPath; |
| |
| Process p = Runtime.getRuntime().exec(command); |
| p.waitFor(); |
| |
| IFileStore fileStore = EFS.getLocalFileSystem().getStore(new Path(tempPath)); |
| if (!fileStore.fetchInfo().isDirectory() && fileStore.fetchInfo().exists()) { |
| // before we open the file in an editor window, we make sure the |
| // current |
| // workbench page has an editor area (typically the ddms |
| // perspective doesn't). |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| IWorkbenchPage page = window.getActivePage(); |
| if (page == null) { |
| return; |
| } |
| |
| if (page.isEditorAreaVisible() == false) { |
| IAdaptable input; |
| input = page.getInput(); |
| try { |
| workbench.showPerspective("org.eclipse.debug.ui.DebugPerspective", //$NON-NLS-1$ |
| window, input); |
| } catch (WorkbenchException e) { |
| } |
| } |
| |
| IDE.openEditorOnFileStore(page, fileStore); |
| } |
| } |
| } |
| |
| public DeviceView() { |
| // the view is declared with allowMultiple="false" so we |
| // can safely do this. |
| sThis = this; |
| } |
| |
| public static DeviceView getInstance() { |
| return sThis; |
| } |
| |
| @Override |
| public void createPartControl(Composite parent) { |
| mParentShell = parent.getShell(); |
| |
| ImageLoader loader = ImageLoader.getDdmUiLibLoader(); |
| |
| mDeviceList = new DevicePanel(USE_SELECTED_DEBUG_PORT); |
| mDeviceList.createPanel(parent); |
| mDeviceList.addSelectionListener(this); |
| |
| DdmsPlugin plugin = DdmsPlugin.getDefault(); |
| mDeviceList.addSelectionListener(plugin); |
| plugin.setListeningState(true); |
| |
| mCaptureAction = new Action(Messages.DeviceView_Screen_Capture) { |
| @Override |
| public void run() { |
| ScreenShotDialog dlg = new ScreenShotDialog( |
| DdmsPlugin.getDisplay().getActiveShell()); |
| dlg.open(mDeviceList.getSelectedDevice()); |
| } |
| }; |
| mCaptureAction.setToolTipText(Messages.DeviceView_Screen_Capture_Tooltip); |
| mCaptureAction.setImageDescriptor(loader.loadDescriptor("capture.png")); //$NON-NLS-1$ |
| |
| mViewUiAutomatorHierarchyAction = new Action("Dump View Hierarchy for UI Automator") { |
| @Override |
| public void run() { |
| takeUiAutomatorSnapshot(mDeviceList.getSelectedDevice(), |
| DdmsPlugin.getDisplay().getActiveShell()); |
| } |
| }; |
| mViewUiAutomatorHierarchyAction.setToolTipText("Dump View Hierarchy for UI Automator"); |
| 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() { |
| AndroidDebugBridge bridge = AndroidDebugBridge.getBridge(); |
| if (bridge != null) { |
| if (bridge.restart() == false) { |
| // get the current Display |
| final Display display = DdmsPlugin.getDisplay(); |
| |
| // dialog box only run in ui thread.. |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openError(shell, Messages.DeviceView_ADB_Error, |
| Messages.DeviceView_ADB_Failed_Restart); |
| } |
| }); |
| } |
| } |
| } |
| }; |
| mResetAdbAction.setToolTipText(Messages.DeviceView_Reset_ADB_Host_Deamon); |
| mResetAdbAction.setImageDescriptor(PlatformUI.getWorkbench() |
| .getSharedImages().getImageDescriptor( |
| ISharedImages.IMG_OBJS_WARN_TSK)); |
| |
| mKillAppAction = new Action() { |
| @Override |
| public void run() { |
| mDeviceList.killSelectedClient(); |
| } |
| }; |
| |
| mKillAppAction.setText(Messages.DeviceView_Stop_Process); |
| mKillAppAction.setToolTipText(Messages.DeviceView_Stop_Process_Tooltip); |
| mKillAppAction.setImageDescriptor(loader.loadDescriptor(DevicePanel.ICON_HALT)); |
| |
| mGcAction = new Action() { |
| @Override |
| public void run() { |
| mDeviceList.forceGcOnSelectedClient(); |
| } |
| }; |
| |
| mGcAction.setText(Messages.DeviceView_Cause_GC); |
| mGcAction.setToolTipText(Messages.DeviceView_Cause_GC_Tooltip); |
| mGcAction.setImageDescriptor(loader.loadDescriptor(DevicePanel.ICON_GC)); |
| |
| mHprofAction = new Action() { |
| @Override |
| public void run() { |
| mDeviceList.dumpHprof(); |
| doSelectionChanged(mDeviceList.getSelectedClient()); |
| } |
| }; |
| mHprofAction.setText(Messages.DeviceView_Dump_HPROF_File); |
| mHprofAction.setToolTipText(Messages.DeviceView_Dump_HPROF_File_Tooltip); |
| mHprofAction.setImageDescriptor(loader.loadDescriptor(DevicePanel.ICON_HPROF)); |
| |
| mUpdateHeapAction = new Action(Messages.DeviceView_Update_Heap, IAction.AS_CHECK_BOX) { |
| @Override |
| public void run() { |
| boolean enable = mUpdateHeapAction.isChecked(); |
| mDeviceList.setEnabledHeapOnSelectedClient(enable); |
| } |
| }; |
| mUpdateHeapAction.setToolTipText(Messages.DeviceView_Update_Heap_Tooltip); |
| mUpdateHeapAction.setImageDescriptor(loader.loadDescriptor(DevicePanel.ICON_HEAP)); |
| |
| mUpdateThreadAction = new Action(Messages.DeviceView_Threads, IAction.AS_CHECK_BOX) { |
| @Override |
| public void run() { |
| boolean enable = mUpdateThreadAction.isChecked(); |
| mDeviceList.setEnabledThreadOnSelectedClient(enable); |
| } |
| }; |
| mUpdateThreadAction.setToolTipText(Messages.DeviceView_Threads_Tooltip); |
| mUpdateThreadAction.setImageDescriptor(loader.loadDescriptor(DevicePanel.ICON_THREAD)); |
| |
| mTracingAction = new Action() { |
| @Override |
| public void run() { |
| mDeviceList.toggleMethodProfiling(); |
| } |
| }; |
| mTracingAction.setText(Messages.DeviceView_Start_Method_Profiling); |
| mTracingAction.setToolTipText(Messages.DeviceView_Start_Method_Profiling_Tooltip); |
| mTracingStartImage = loader.loadDescriptor(DevicePanel.ICON_TRACING_START); |
| mTracingStopImage = loader.loadDescriptor(DevicePanel.ICON_TRACING_STOP); |
| mTracingAction.setImageDescriptor(mTracingStartImage); |
| |
| mDebugAction = new Action(Messages.DeviceView_Debug_Process) { |
| @Override |
| public void run() { |
| if (DdmsPlugin.getDefault().hasDebuggerConnectors()) { |
| Client currentClient = mDeviceList.getSelectedClient(); |
| if (currentClient != null) { |
| ClientData clientData = currentClient.getClientData(); |
| |
| // make sure the client can be debugged |
| switch (clientData.getDebuggerConnectionStatus()) { |
| case ERROR: { |
| Display display = DdmsPlugin.getDisplay(); |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openError(shell, |
| Messages.DeviceView_Debug_Process_Title, |
| Messages.DeviceView_Process_Debug_Already_In_Use); |
| return; |
| } |
| case ATTACHED: { |
| Display display = DdmsPlugin.getDisplay(); |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openError(shell, |
| Messages.DeviceView_Debug_Process_Title, |
| Messages.DeviceView_Process_Already_Being_Debugged); |
| return; |
| } |
| } |
| |
| // get the name of the client |
| String packageName = clientData.getClientDescription(); |
| if (packageName != null) { |
| |
| // try all connectors till one returns true. |
| IDebuggerConnector[] connectors = |
| DdmsPlugin.getDefault().getDebuggerConnectors(); |
| |
| if (connectors != null) { |
| for (IDebuggerConnector connector : connectors) { |
| try { |
| if (connector.connectDebugger(packageName, |
| currentClient.getDebuggerListenPort(), |
| DdmPreferences.getSelectedDebugPort())) { |
| return; |
| } |
| } catch (Throwable t) { |
| // ignore, we'll just not use this |
| // implementation |
| } |
| } |
| } |
| |
| // if we get to this point, then we failed to find a |
| // project |
| // that matched the application to debug |
| Display display = DdmsPlugin.getDisplay(); |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openError(shell, Messages.DeviceView_Debug_Process_Title, |
| String.format( |
| Messages.DeviceView_Debug_Session_Failed, |
| packageName)); |
| } |
| } |
| } |
| } |
| }; |
| mDebugAction.setToolTipText(Messages.DeviceView_Debug_Process_Tooltip); |
| mDebugAction.setImageDescriptor(loader.loadDescriptor("debug-attach.png")); //$NON-NLS-1$ |
| mDebugAction.setEnabled(DdmsPlugin.getDefault().hasDebuggerConnectors()); |
| |
| placeActions(); |
| |
| // disabling all action buttons |
| selectionChanged(null, null); |
| |
| ClientData.setHprofDumpHandler(new HProfHandler(mParentShell)); |
| AndroidDebugBridge.addClientChangeListener(this); |
| ClientData.setMethodProfilingHandler(new MethodProfilingHandler(mParentShell) { |
| @Override |
| protected void open(String tempPath) { |
| if (DdmsPlugin.getDefault().launchTraceview(tempPath) == false) { |
| super.open(tempPath); |
| } |
| } |
| }); |
| } |
| |
| private void takeUiAutomatorSnapshot(final IDevice device, final Shell shell) { |
| ProgressMonitorDialog dialog = new ProgressMonitorDialog(shell); |
| try { |
| dialog.run(true, false, new IRunnableWithProgress() { |
| @Override |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, |
| InterruptedException { |
| UiAutomatorResult result = null; |
| try { |
| result = UiAutomatorHelper.takeSnapshot(device, monitor); |
| } catch (UiAutomatorException e) { |
| throw new InvocationTargetException(e); |
| } finally { |
| monitor.done(); |
| } |
| |
| UiAutomatorViewer.openEditor(result); |
| } |
| }); |
| } catch (Exception e) { |
| Throwable t = e; |
| if (e instanceof InvocationTargetException) { |
| t = ((InvocationTargetException) e).getTargetException(); |
| } |
| Status s = new Status(IStatus.ERROR, DdmsPlugin.PLUGIN_ID, |
| "Error obtaining UI hierarchy", t); |
| ErrorDialog.openError(shell, "UI Automator", |
| "Unexpected error while obtaining UI hierarchy", s); |
| } |
| }; |
| |
| private void launchSystrace(final IDevice device, final Shell parentShell) { |
| final File systraceAssets = new File(DdmsPlugin.getPlatformToolsFolder(), "systrace"); //$NON-NLS-1$ |
| if (!systraceAssets.isDirectory()) { |
| MessageDialog.openError(parentShell, "Systrace", |
| "Updated version of platform-tools (18.0.1 or greater) is required.\n" |
| + "Please update your platform-tools using SDK Manager."); |
| return; |
| } |
| |
| SystraceVersionDetector detector = new SystraceVersionDetector(device); |
| try { |
| new ProgressMonitorDialog(parentShell).run(true, false, detector); |
| } catch (InvocationTargetException e) { |
| MessageDialog.openError(parentShell, |
| "Systrace", |
| "Unexpected error while detecting atrace version: " + e); |
| return; |
| } catch (InterruptedException e) { |
| return; |
| } |
| |
| final ISystraceOptionsDialog dlg; |
| if (detector.getVersion() == SystraceVersionDetector.SYSTRACE_V1) { |
| dlg = new SystraceOptionsDialogV1(parentShell); |
| } else { |
| Client[] clients = device.getClients(); |
| List<String> apps = new ArrayList<String>(clients.length); |
| for (int i = 0; i < clients.length; i++) { |
| String name = clients[i].getClientData().getClientDescription(); |
| if (name != null && !name.isEmpty()) { |
| apps.add(name); |
| } |
| } |
| dlg = new SystraceOptionsDialogV2(parentShell, detector.getTags(), apps); |
| } |
| |
| if (dlg.open() != SystraceOptionsDialogV1.OK) { |
| return; |
| } |
| |
| final ISystraceOptions options = dlg.getSystraceOptions(); |
| |
| // set trace tag if necessary: |
| // adb shell setprop debug.atrace.tags.enableflags <tag> |
| String tag = options.getTags(); |
| 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.getOptions() |
| + (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"); |
| SystraceOutputParser parser = new SystraceOutputParser( |
| COMPRESS_DATA, |
| SystraceOutputParser.getJs(systraceAssets), |
| SystraceOutputParser.getCss(systraceAssets), |
| SystraceOutputParser.getHtmlPrefix(systraceAssets), |
| SystraceOutputParser.getHtmlSuffix(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() { |
| mDeviceList.setFocus(); |
| } |
| |
| /** |
| * Sent when a new {@link IDevice} and {@link Client} are selected. |
| * |
| * @param selectedDevice the selected device. If null, no devices are |
| * selected. |
| * @param selectedClient The selected client. If null, no clients are |
| * selected. |
| */ |
| @Override |
| public void selectionChanged(IDevice selectedDevice, Client selectedClient) { |
| // update the buttons |
| doSelectionChanged(selectedClient); |
| doSelectionChanged(selectedDevice); |
| } |
| |
| private void doSelectionChanged(Client selectedClient) { |
| // update the buttons |
| if (selectedClient != null) { |
| if (USE_SELECTED_DEBUG_PORT) { |
| // set the client as the debug client |
| selectedClient.setAsSelectedClient(); |
| } |
| |
| mDebugAction.setEnabled(DdmsPlugin.getDefault().hasDebuggerConnectors()); |
| mKillAppAction.setEnabled(true); |
| mGcAction.setEnabled(true); |
| |
| mUpdateHeapAction.setEnabled(true); |
| mUpdateHeapAction.setChecked(selectedClient.isHeapUpdateEnabled()); |
| |
| mUpdateThreadAction.setEnabled(true); |
| mUpdateThreadAction.setChecked(selectedClient.isThreadUpdateEnabled()); |
| |
| ClientData data = selectedClient.getClientData(); |
| |
| if (data.hasFeature(ClientData.FEATURE_HPROF)) { |
| mHprofAction.setEnabled(data.hasPendingHprofDump() == false); |
| mHprofAction.setToolTipText(Messages.DeviceView_Dump_HPROF_File); |
| } else { |
| mHprofAction.setEnabled(false); |
| mHprofAction |
| .setToolTipText(Messages.DeviceView_Dump_HPROF_File_Not_Supported_By_VM); |
| } |
| |
| if (data.hasFeature(ClientData.FEATURE_PROFILING)) { |
| mTracingAction.setEnabled(true); |
| if (data.getMethodProfilingStatus() == MethodProfilingStatus.TRACER_ON |
| || data.getMethodProfilingStatus() == MethodProfilingStatus.SAMPLER_ON) { |
| mTracingAction |
| .setToolTipText(Messages.DeviceView_Stop_Method_Profiling_Tooltip); |
| mTracingAction.setText(Messages.DeviceView_Stop_Method_Profiling); |
| mTracingAction.setImageDescriptor(mTracingStopImage); |
| } else { |
| mTracingAction |
| .setToolTipText(Messages.DeviceView_Start_Method_Profiling_Tooltip); |
| mTracingAction.setImageDescriptor(mTracingStartImage); |
| mTracingAction.setText(Messages.DeviceView_Start_Method_Profiling); |
| } |
| } else { |
| mTracingAction.setEnabled(false); |
| mTracingAction.setImageDescriptor(mTracingStartImage); |
| mTracingAction |
| .setToolTipText(Messages.DeviceView_Start_Method_Profiling_Not_Suported_By_Vm); |
| mTracingAction.setText(Messages.DeviceView_Start_Method_Profiling); |
| } |
| } else { |
| if (USE_SELECTED_DEBUG_PORT) { |
| // set the client as the debug client |
| AndroidDebugBridge bridge = AndroidDebugBridge.getBridge(); |
| if (bridge != null) { |
| bridge.setSelectedClient(null); |
| } |
| } |
| |
| mDebugAction.setEnabled(false); |
| mKillAppAction.setEnabled(false); |
| mGcAction.setEnabled(false); |
| mUpdateHeapAction.setChecked(false); |
| mUpdateHeapAction.setEnabled(false); |
| mUpdateThreadAction.setEnabled(false); |
| mUpdateThreadAction.setChecked(false); |
| mHprofAction.setEnabled(false); |
| |
| mHprofAction.setEnabled(false); |
| mHprofAction.setToolTipText(Messages.DeviceView_Dump_HPROF_File); |
| |
| mTracingAction.setEnabled(false); |
| mTracingAction.setImageDescriptor(mTracingStartImage); |
| mTracingAction.setToolTipText(Messages.DeviceView_Start_Method_Profiling_Tooltip); |
| mTracingAction.setText(Messages.DeviceView_Start_Method_Profiling); |
| } |
| |
| for (IClientAction a : DdmsPlugin.getDefault().getClientSpecificActions()) { |
| a.selectedClientChanged(selectedClient); |
| } |
| } |
| |
| private void doSelectionChanged(IDevice selectedDevice) { |
| boolean validDevice = selectedDevice != null; |
| |
| mCaptureAction.setEnabled(validDevice); |
| mViewUiAutomatorHierarchyAction.setEnabled(validDevice); |
| mSystraceAction.setEnabled(validDevice); |
| } |
| |
| /** |
| * Place the actions in the ui. |
| */ |
| private final void placeActions() { |
| IActionBars actionBars = getViewSite().getActionBars(); |
| |
| // first in the menu |
| IMenuManager menuManager = actionBars.getMenuManager(); |
| menuManager.removeAll(); |
| menuManager.add(mDebugAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mUpdateHeapAction); |
| menuManager.add(mHprofAction); |
| menuManager.add(mGcAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mUpdateThreadAction); |
| menuManager.add(mTracingAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mKillAppAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mCaptureAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mViewUiAutomatorHierarchyAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mSystraceAction); |
| menuManager.add(new Separator()); |
| menuManager.add(mResetAdbAction); |
| for (IClientAction a : DdmsPlugin.getDefault().getClientSpecificActions()) { |
| menuManager.add(a.getAction()); |
| } |
| |
| // and then in the toolbar |
| IToolBarManager toolBarManager = actionBars.getToolBarManager(); |
| toolBarManager.removeAll(); |
| toolBarManager.add(mDebugAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mUpdateHeapAction); |
| toolBarManager.add(mHprofAction); |
| toolBarManager.add(mGcAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mUpdateThreadAction); |
| toolBarManager.add(mTracingAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mKillAppAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mCaptureAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mViewUiAutomatorHierarchyAction); |
| toolBarManager.add(new Separator()); |
| toolBarManager.add(mSystraceAction); |
| for (IClientAction a : DdmsPlugin.getDefault().getClientSpecificActions()) { |
| toolBarManager.add(a.getAction()); |
| } |
| } |
| |
| @Override |
| public void clientChanged(final Client client, int changeMask) { |
| if ((changeMask & Client.CHANGE_METHOD_PROFILING_STATUS) == Client.CHANGE_METHOD_PROFILING_STATUS) { |
| if (mDeviceList.getSelectedClient() == client) { |
| mParentShell.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| // force refresh of the button enabled state. |
| doSelectionChanged(client); |
| } |
| }); |
| } |
| } |
| } |
| } |
