Java tutorial
/* * Copyright (C) 2007 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; import com.android.annotations.NonNull; import com.android.ddmlib.AndroidDebugBridge; import com.android.ddmlib.AndroidDebugBridge.IDeviceChangeListener; import com.android.ddmlib.Client; import com.android.ddmlib.DdmPreferences; import com.android.ddmlib.IDevice; import com.android.ddmlib.Log; import com.android.ddmlib.Log.ILogOutput; import com.android.ddmlib.Log.LogLevel; import com.android.ddmuilib.DdmUiPreferences; import com.android.ddmuilib.DevicePanel.IUiSelectionListener; import com.android.ddmuilib.StackTracePanel; import com.android.ddmuilib.console.DdmConsole; import com.android.ddmuilib.console.IDdmConsole; import com.android.ide.eclipse.ddms.i18n.Messages; import com.android.ide.eclipse.ddms.preferences.PreferenceInitializer; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IConfigurationElement; import org.eclipse.core.runtime.IExtensionPoint; import org.eclipse.core.runtime.IExtensionRegistry; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.util.IPropertyChangeListener; import org.eclipse.jface.util.PropertyChangeEvent; import org.eclipse.swt.SWTException; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.console.ConsolePlugin; import org.eclipse.ui.console.IConsole; import org.eclipse.ui.console.MessageConsole; import org.eclipse.ui.console.MessageConsoleStream; import org.eclipse.ui.plugin.AbstractUIPlugin; import org.osgi.framework.BundleContext; import java.io.File; import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.List; /** * The activator class controls the plug-in life cycle */ public final class DdmsPlugin extends AbstractUIPlugin implements IDeviceChangeListener, IUiSelectionListener, com.android.ddmuilib.StackTracePanel.ISourceRevealer { // The plug-in ID public static final String PLUGIN_ID = "com.android.ide.eclipse.ddms"; //$NON-NLS-1$ /** The singleton instance */ private static DdmsPlugin sPlugin; /** Location of the adb command line executable */ private static String sAdbLocation; private static String sToolsFolder; private static String sHprofConverter; private boolean mHasDebuggerConnectors; /** debugger connectors for already running apps. * Initialized from an extension point. */ private IDebuggerConnector[] mDebuggerConnectors; private ITraceviewLauncher[] mTraceviewLaunchers; private List<IClientAction> mClientSpecificActions = null; /** Console for DDMS log message */ private MessageConsole mDdmsConsole; private IDevice mCurrentDevice; private Client mCurrentClient; private boolean mListeningToUiSelection = false; private final ArrayList<ISelectionListener> mListeners = new ArrayList<ISelectionListener>(); private Color mRed; /** * Classes which implement this interface provide methods that deals * with {@link IDevice} and {@link Client} selectionchanges. */ public interface ISelectionListener { /** * Sent when a new {@link Client} is selected. * @param selectedClient The selected client. If null, no clients are selected. */ public void selectionChanged(Client selectedClient); /** * Sent when a new {@link IDevice} is selected. * @param selectedDevice the selected device. If null, no devices are selected. */ public void selectionChanged(IDevice selectedDevice); } /** * The constructor */ public DdmsPlugin() { sPlugin = this; } /* * (non-Javadoc) * * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext) */ @Override public void start(BundleContext context) throws Exception { super.start(context); final Display display = getDisplay(); // get the eclipse store final IPreferenceStore eclipseStore = getPreferenceStore(); AndroidDebugBridge.addDeviceChangeListener(this); DdmUiPreferences.setStore(eclipseStore); //DdmUiPreferences.displayCharts(); // set the consoles. mDdmsConsole = new MessageConsole("DDMS", null); //$NON-NLS-1$ ConsolePlugin.getDefault().getConsoleManager().addConsoles(new IConsole[] { mDdmsConsole }); final MessageConsoleStream consoleStream = mDdmsConsole.newMessageStream(); final MessageConsoleStream errorConsoleStream = mDdmsConsole.newMessageStream(); mRed = new Color(display, 0xFF, 0x00, 0x00); // because this can be run, in some cases, by a non UI thread, and because // changing the console properties update the UI, we need to make this change // in the UI thread. display.asyncExec(new Runnable() { @Override public void run() { errorConsoleStream.setColor(mRed); } }); // set up the ddms log to use the ddms console. Log.setLogOutput(new ILogOutput() { @Override public void printLog(LogLevel logLevel, String tag, String message) { if (logLevel.getPriority() >= LogLevel.ERROR.getPriority()) { printToStream(errorConsoleStream, tag, message); showConsoleView(mDdmsConsole); } else { printToStream(consoleStream, tag, message); } } @Override public void printAndPromptLog(final LogLevel logLevel, final String tag, final String message) { printLog(logLevel, tag, message); // dialog box only run in UI thread.. display.asyncExec(new Runnable() { @Override public void run() { Shell shell = display.getActiveShell(); if (logLevel == LogLevel.ERROR) { MessageDialog.openError(shell, tag, message); } else { MessageDialog.openWarning(shell, tag, message); } } }); } }); // set up the ddms console to use this objects DdmConsole.setConsole(new IDdmConsole() { @Override public void printErrorToConsole(String message) { printToStream(errorConsoleStream, null, message); showConsoleView(mDdmsConsole); } @Override public void printErrorToConsole(String[] messages) { for (String m : messages) { printToStream(errorConsoleStream, null, m); } showConsoleView(mDdmsConsole); } @Override public void printToConsole(String message) { printToStream(consoleStream, null, message); } @Override public void printToConsole(String[] messages) { for (String m : messages) { printToStream(consoleStream, null, m); } } }); // set the listener for the preference change eclipseStore.addPropertyChangeListener(new IPropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent event) { // get the name of the property that changed. String property = event.getProperty(); if (PreferenceInitializer.ATTR_DEBUG_PORT_BASE.equals(property)) { DdmPreferences .setDebugPortBase(eclipseStore.getInt(PreferenceInitializer.ATTR_DEBUG_PORT_BASE)); } else if (PreferenceInitializer.ATTR_SELECTED_DEBUG_PORT.equals(property)) { DdmPreferences.setSelectedDebugPort( eclipseStore.getInt(PreferenceInitializer.ATTR_SELECTED_DEBUG_PORT)); } else if (PreferenceInitializer.ATTR_THREAD_INTERVAL.equals(property)) { DdmUiPreferences.setThreadRefreshInterval( eclipseStore.getInt(PreferenceInitializer.ATTR_THREAD_INTERVAL)); } else if (PreferenceInitializer.ATTR_LOG_LEVEL.equals(property)) { DdmPreferences.setLogLevel(eclipseStore.getString(PreferenceInitializer.ATTR_LOG_LEVEL)); } else if (PreferenceInitializer.ATTR_TIME_OUT.equals(property)) { DdmPreferences.setTimeOut(eclipseStore.getInt(PreferenceInitializer.ATTR_TIME_OUT)); } else if (PreferenceInitializer.ATTR_USE_ADBHOST.equals(property)) { DdmPreferences.setUseAdbHost(eclipseStore.getBoolean(PreferenceInitializer.ATTR_USE_ADBHOST)); } else if (PreferenceInitializer.ATTR_ADBHOST_VALUE.equals(property)) { DdmPreferences .setAdbHostValue(eclipseStore.getString(PreferenceInitializer.ATTR_ADBHOST_VALUE)); } } }); // do some last initializations // set the preferences. PreferenceInitializer.setupPreferences(); // this class is set as the main source revealer and will look at all the implementations // of the extension point. see #reveal(String, String, int) StackTracePanel.setSourceRevealer(this); /* * Load the extension point implementations. * The first step is to load the IConfigurationElement representing the implementations. * The 2nd step is to use these objects to instantiate the implementation classes. * * Because the 2nd step will trigger loading the plug-ins providing the implementations, * and those plug-ins could access DDMS classes (like ADT), this 2nd step should be done * in a Job to ensure that DDMS is loaded, so that the other plug-ins can load. * * Both steps could be done in the 2nd step but some of DDMS UI rely on knowing if there * is an implementation or not (DeviceView), so we do the first steps in start() and, in * some case, record it. * */ // get the IConfigurationElement for the debuggerConnector right away. final IConfigurationElement[] dcce = findConfigElements("com.android.ide.eclipse.ddms.debuggerConnector"); //$NON-NLS-1$ mHasDebuggerConnectors = dcce.length > 0; // get the other configElements and instantiante them in a Job. new Job(Messages.DdmsPlugin_DDMS_Post_Create_Init) { @Override protected IStatus run(IProgressMonitor monitor) { try { // init the lib AndroidDebugBridge.init(true /* debugger support */); // get the available adb locators IConfigurationElement[] elements = findConfigElements( "com.android.ide.eclipse.ddms.toolsLocator"); //$NON-NLS-1$ IToolsLocator[] locators = instantiateToolsLocators(elements); for (IToolsLocator locator : locators) { try { String adbLocation = locator.getAdbLocation(); String traceviewLocation = locator.getTraceViewLocation(); String hprofConvLocation = locator.getHprofConvLocation(); if (adbLocation != null && traceviewLocation != null && hprofConvLocation != null) { // checks if the location is valid. if (setToolsLocation(adbLocation, hprofConvLocation, traceviewLocation)) { AndroidDebugBridge.createBridge(sAdbLocation, true /* forceNewBridge */); // no need to look at the other locators. break; } } } catch (Throwable t) { // ignore, we'll just not use this implementation. } } // get the available debugger connectors mDebuggerConnectors = instantiateDebuggerConnectors(dcce); // get the available Traceview Launchers. elements = findConfigElements("com.android.ide.eclipse.ddms.traceviewLauncher"); //$NON-NLS-1$ mTraceviewLaunchers = instantiateTraceviewLauncher(elements); return Status.OK_STATUS; } catch (CoreException e) { return e.getStatus(); } } }.schedule(); } private void showConsoleView(MessageConsole console) { ConsolePlugin.getDefault().getConsoleManager().showConsoleView(console); } /** Obtain a list of configuration elements that extend the given extension point. */ IConfigurationElement[] findConfigElements(String extensionPointId) { // get the adb location from an implementation of the ADB Locator extension point. IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint(extensionPointId); if (extensionPoint != null) { return extensionPoint.getConfigurationElements(); } // shouldn't happen or it means the plug-in is broken. return new IConfigurationElement[0]; } /** * Finds if any other plug-in is extending the exposed Extension Point called adbLocator. * * @return an array of all locators found, or an empty array if none were found. */ private IToolsLocator[] instantiateToolsLocators(IConfigurationElement[] configElements) throws CoreException { ArrayList<IToolsLocator> list = new ArrayList<IToolsLocator>(); if (configElements.length > 0) { // only use the first one, ignore the others. IConfigurationElement configElement = configElements[0]; // instantiate the class Object obj = configElement.createExecutableExtension("class"); //$NON-NLS-1$ if (obj instanceof IToolsLocator) { list.add((IToolsLocator) obj); } } return list.toArray(new IToolsLocator[list.size()]); } /** * Finds if any other plug-in is extending the exposed Extension Point called debuggerConnector. * * @return an array of all locators found, or an empty array if none were found. */ private IDebuggerConnector[] instantiateDebuggerConnectors(IConfigurationElement[] configElements) throws CoreException { ArrayList<IDebuggerConnector> list = new ArrayList<IDebuggerConnector>(); if (configElements.length > 0) { // only use the first one, ignore the others. IConfigurationElement configElement = configElements[0]; // instantiate the class Object obj = configElement.createExecutableExtension("class"); //$NON-NLS-1$ if (obj instanceof IDebuggerConnector) { list.add((IDebuggerConnector) obj); } } return list.toArray(new IDebuggerConnector[list.size()]); } /** * Finds if any other plug-in is extending the exposed Extension Point called traceviewLauncher. * * @return an array of all locators found, or an empty array if none were found. */ private ITraceviewLauncher[] instantiateTraceviewLauncher(IConfigurationElement[] configElements) throws CoreException { ArrayList<ITraceviewLauncher> list = new ArrayList<ITraceviewLauncher>(); if (configElements.length > 0) { // only use the first one, ignore the others. IConfigurationElement configElement = configElements[0]; // instantiate the class Object obj = configElement.createExecutableExtension("class"); //$NON-NLS-1$ if (obj instanceof ITraceviewLauncher) { list.add((ITraceviewLauncher) obj); } } return list.toArray(new ITraceviewLauncher[list.size()]); } /** * Returns the classes that implement {@link IClientAction} in each of the extensions that * extend clientAction extension point. * @throws CoreException */ private List<IClientAction> instantiateClientSpecificActions(IConfigurationElement[] elements) throws CoreException { if (elements == null || elements.length == 0) { return Collections.emptyList(); } List<IClientAction> extensions = new ArrayList<IClientAction>(1); for (IConfigurationElement e : elements) { Object o = e.createExecutableExtension("class"); //$NON-NLS-1$ if (o instanceof IClientAction) { extensions.add((IClientAction) o); } } return extensions; } public static Display getDisplay() { IWorkbench bench = sPlugin.getWorkbench(); if (bench != null) { return bench.getDisplay(); } return null; } /* * (non-Javadoc) * * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext) */ @Override public void stop(BundleContext context) throws Exception { AndroidDebugBridge.removeDeviceChangeListener(this); AndroidDebugBridge.terminate(); mRed.dispose(); sPlugin = null; super.stop(context); } /** * Returns the shared instance * * @return the shared instance */ public static DdmsPlugin getDefault() { return sPlugin; } public static String getAdb() { return sAdbLocation; } public static File getPlatformToolsFolder() { return new File(sAdbLocation).getParentFile(); } public static String getToolsFolder() { return sToolsFolder; } public static String getHprofConverter() { return sHprofConverter; } /** * Stores the adb location. This returns true if the location is an existing file. */ private static boolean setToolsLocation(String adbLocation, String hprofConvLocation, String traceViewLocation) { File adb = new File(adbLocation); File hprofConverter = new File(hprofConvLocation); File traceview = new File(traceViewLocation); String missing = ""; if (adb.isFile() == false) { missing += adb.getAbsolutePath() + " "; } if (hprofConverter.isFile() == false) { missing += hprofConverter.getAbsolutePath() + " "; } if (traceview.isFile() == false) { missing += traceview.getAbsolutePath() + " "; } if (missing.length() > 0) { String msg = String.format("DDMS files not found: %1$s", missing); Log.e("DDMS", msg); Status status = new Status(IStatus.ERROR, PLUGIN_ID, msg, null /*exception*/); getDefault().getLog().log(status); return false; } sAdbLocation = adbLocation; sHprofConverter = hprofConverter.getAbsolutePath(); DdmUiPreferences.setTraceviewLocation(traceview.getAbsolutePath()); sToolsFolder = traceview.getParent(); return true; } /** * Set the location of the adb executable and optionally starts adb * @param adb location of adb * @param startAdb flag to start adb */ public static void setToolsLocation(String adbLocation, boolean startAdb, String hprofConvLocation, String traceViewLocation) { if (setToolsLocation(adbLocation, hprofConvLocation, traceViewLocation)) { // starts the server in a thread in case this is blocking. if (startAdb) { new Thread() { @Override public void run() { // create and start the bridge try { AndroidDebugBridge.createBridge(sAdbLocation, false /* forceNewBridge */); } catch (Throwable t) { Status status = new Status(IStatus.ERROR, PLUGIN_ID, "Failed to create AndroidDebugBridge", t); getDefault().getLog().log(status); } } }.start(); } } } /** * Returns whether there are implementations of the debuggerConnectors extension point. * <p/> * This is guaranteed to return the correct value as soon as the plug-in is loaded. */ public boolean hasDebuggerConnectors() { return mHasDebuggerConnectors; } /** * Returns the implementations of {@link IDebuggerConnector}. * <p/> * There may be a small amount of time right after the plug-in load where this can return * null even if there are implementation. * <p/> * Since the use of the implementation likely require user input, the UI can use * {@link #hasDebuggerConnectors()} to know if there are implementations before they are loaded. */ public IDebuggerConnector[] getDebuggerConnectors() { return mDebuggerConnectors; } public synchronized void addSelectionListener(ISelectionListener listener) { mListeners.add(listener); // notify the new listener of the current selection listener.selectionChanged(mCurrentDevice); listener.selectionChanged(mCurrentClient); } public synchronized void removeSelectionListener(ISelectionListener listener) { mListeners.remove(listener); } public synchronized void setListeningState(boolean state) { mListeningToUiSelection = state; } /** * Sent when the a device is connected to the {@link AndroidDebugBridge}. * <p/> * This is sent from a non UI thread. * @param device the new device. * * @see IDeviceChangeListener#deviceConnected(IDevice) */ @Override public void deviceConnected(IDevice device) { // if we are listening to selection coming from the ui, then we do nothing, as // any change in the devices/clients, will be handled by the UI, and we'll receive // selection notification through our implementation of IUiSelectionListener. if (mListeningToUiSelection == false) { if (mCurrentDevice == null) { handleDefaultSelection(device); } } } /** * Sent when the a device is disconnected to the {@link AndroidDebugBridge}. * <p/> * This is sent from a non UI thread. * @param device the new device. * * @see IDeviceChangeListener#deviceDisconnected(IDevice) */ @Override public void deviceDisconnected(IDevice device) { // if we are listening to selection coming from the ui, then we do nothing, as // any change in the devices/clients, will be handled by the UI, and we'll receive // selection notification through our implementation of IUiSelectionListener. if (mListeningToUiSelection == false) { // test if the disconnected device was the default selection. if (mCurrentDevice == device) { // try to find a new device AndroidDebugBridge bridge = AndroidDebugBridge.getBridge(); if (bridge != null) { // get the device list IDevice[] devices = bridge.getDevices(); // check if we still have devices if (devices.length == 0) { handleDefaultSelection((IDevice) null); } else { handleDefaultSelection(devices[0]); } } else { handleDefaultSelection((IDevice) null); } } } } /** * Sent when a device data changed, or when clients are started/terminated on the device. * <p/> * This is sent from a non UI thread. * @param device the device that was updated. * @param changeMask the mask indicating what changed. * * @see IDeviceChangeListener#deviceChanged(IDevice) */ @Override public void deviceChanged(IDevice device, int changeMask) { // if we are listening to selection coming from the ui, then we do nothing, as // any change in the devices/clients, will be handled by the UI, and we'll receive // selection notification through our implementation of IUiSelectionListener. if (mListeningToUiSelection == false) { // check if this is our device if (device == mCurrentDevice) { if (mCurrentClient == null) { handleDefaultSelection(device); } else { // get the clients and make sure ours is still in there. Client[] clients = device.getClients(); boolean foundClient = false; for (Client client : clients) { if (client == mCurrentClient) { foundClient = true; break; } } // if we haven't found our client, lets look for a new one if (foundClient == false) { mCurrentClient = null; handleDefaultSelection(device); } } } } } /** * 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 synchronized void selectionChanged(IDevice selectedDevice, Client selectedClient) { if (mCurrentDevice != selectedDevice) { mCurrentDevice = selectedDevice; // notify of the new default device for (ISelectionListener listener : mListeners) { listener.selectionChanged(mCurrentDevice); } } if (mCurrentClient != selectedClient) { mCurrentClient = selectedClient; // notify of the new default client for (ISelectionListener listener : mListeners) { listener.selectionChanged(mCurrentClient); } } } /** * Handles a default selection of a {@link IDevice} and {@link Client}. * @param device the selected device */ private void handleDefaultSelection(final IDevice device) { // because the listener expect to receive this from the UI thread, and this is called // from the AndroidDebugBridge notifications, we need to run this in the UI thread. try { Display display = getDisplay(); display.asyncExec(new Runnable() { @Override public void run() { // set the new device if different. boolean newDevice = false; if (mCurrentDevice != device) { mCurrentDevice = device; newDevice = true; // notify of the new default device for (ISelectionListener listener : mListeners) { listener.selectionChanged(mCurrentDevice); } } if (device != null) { // if this is a device switch or the same device but we didn't find a valid // client the last time, we go look for a client to use again. if (newDevice || mCurrentClient == null) { // now get the new client Client[] clients = device.getClients(); if (clients.length > 0) { handleDefaultSelection(clients[0]); } else { handleDefaultSelection((Client) null); } } } else { handleDefaultSelection((Client) null); } } }); } catch (SWTException e) { // display is disposed. Do nothing since we're quitting anyway. } } private void handleDefaultSelection(Client client) { mCurrentClient = client; // notify of the new default client for (ISelectionListener listener : mListeners) { listener.selectionChanged(mCurrentClient); } } /** * Prints a message, associated with a project to the specified stream * @param stream The stream to write to * @param tag The tag associated to the message. Can be null * @param message The message to print. */ private static synchronized void printToStream(MessageConsoleStream stream, String tag, String message) { String dateTag = getMessageTag(tag); stream.print(dateTag); if (!dateTag.endsWith(" ")) { stream.print(" "); //$NON-NLS-1$ } stream.println(message); } /** * Creates a string containing the current date/time, and the tag * @param tag The tag associated to the message. Can be null * @return The dateTag */ private static String getMessageTag(String tag) { Calendar c = Calendar.getInstance(); if (tag == null) { return String.format(Messages.DdmsPlugin_Message_Tag_Mask_1, c); } return String.format(Messages.DdmsPlugin_Message_Tag_Mask_2, c, tag); } /** * Implementation of com.android.ddmuilib.StackTracePanel.ISourceRevealer. */ @Override public void reveal(String applicationName, String className, int line) { JavaSourceRevealer.reveal(applicationName, className, line); } public boolean launchTraceview(String osPath) { if (mTraceviewLaunchers != null) { for (ITraceviewLauncher launcher : mTraceviewLaunchers) { try { if (launcher.openFile(osPath)) { return true; } } catch (Throwable t) { // ignore, we'll just not use this implementation. } } } return false; } /** * Returns the list of clients that extend the clientAction extension point. */ @NonNull public synchronized List<IClientAction> getClientSpecificActions() { if (mClientSpecificActions == null) { // get available client specific action extensions IConfigurationElement[] elements = findConfigElements("com.android.ide.eclipse.ddms.clientAction"); //$NON-NLS-1$ try { mClientSpecificActions = instantiateClientSpecificActions(elements); } catch (CoreException e) { mClientSpecificActions = Collections.emptyList(); } } return mClientSpecificActions; } private LogCatMonitor mLogCatMonitor; public void startLogCatMonitor(IDevice device) { if (mLogCatMonitor == null) { mLogCatMonitor = new LogCatMonitor(getDebuggerConnectors(), getPreferenceStore()); } mLogCatMonitor.monitorDevice(device); } /** Returns an image descriptor for the image file at the given plug-in relative path */ public static ImageDescriptor getImageDescriptor(String path) { return imageDescriptorFromPlugin(PLUGIN_ID, path); } }