| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.adt; |
| |
| import static com.android.SdkConstants.CURRENT_PLATFORM; |
| import static com.android.SdkConstants.PLATFORM_DARWIN; |
| import static com.android.SdkConstants.PLATFORM_LINUX; |
| import static com.android.SdkConstants.PLATFORM_WINDOWS; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.resources.ResourceFile; |
| import com.android.ide.common.sdk.LoadStatus; |
| import com.android.ide.eclipse.adt.AdtPlugin.CheckSdkErrorHandler.Solution; |
| import com.android.ide.eclipse.adt.internal.VersionCheck; |
| import com.android.ide.eclipse.adt.internal.actions.SdkManagerAction; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.IncludeFinder; |
| import com.android.ide.eclipse.adt.internal.lint.LintDeltaProcessor; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs.BuildVerbosity; |
| import com.android.ide.eclipse.adt.internal.project.AndroidClasspathContainerInitializer; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.project.ProjectHelper; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IFileListener; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IProjectListener; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk.ITargetChangeListener; |
| import com.android.ide.eclipse.adt.internal.ui.EclipseUiHelper; |
| import com.android.ide.eclipse.ddms.DdmsPlugin; |
| import com.android.io.StreamException; |
| import com.android.resources.ResourceFolderType; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.utils.ILogger; |
| import com.google.common.collect.Sets; |
| import com.google.common.io.Closeables; |
| |
| import org.eclipse.core.commands.Command; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarkerDelta; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResourceDelta; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.ui.JavaUI; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorDescriptor; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.browser.IWebBrowser; |
| import org.eclipse.ui.browser.IWorkbenchBrowserSupport; |
| import org.eclipse.ui.commands.ICommandService; |
| import org.eclipse.ui.console.ConsolePlugin; |
| import org.eclipse.ui.console.IConsole; |
| import org.eclipse.ui.console.IConsoleConstants; |
| import org.eclipse.ui.console.MessageConsole; |
| import org.eclipse.ui.console.MessageConsoleStream; |
| import org.eclipse.ui.dialogs.PreferencesUtil; |
| import org.eclipse.ui.handlers.IHandlerService; |
| import org.eclipse.ui.ide.IDE; |
| import org.eclipse.ui.plugin.AbstractUIPlugin; |
| import org.eclipse.ui.texteditor.AbstractTextEditor; |
| import org.eclipse.wb.internal.core.DesignerPlugin; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| |
| import java.io.BufferedInputStream; |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * The activator class controls the plug-in life cycle |
| */ |
| public class AdtPlugin extends AbstractUIPlugin implements ILogger { |
| /** The plug-in ID */ |
| public static final String PLUGIN_ID = "com.android.ide.eclipse.adt"; //$NON-NLS-1$ |
| |
| /** singleton instance */ |
| private static AdtPlugin sPlugin; |
| |
| private static Image sAndroidLogo; |
| private static ImageDescriptor sAndroidLogoDesc; |
| |
| /** The global android console */ |
| private MessageConsole mAndroidConsole; |
| |
| /** Stream to write in the android console */ |
| private MessageConsoleStream mAndroidConsoleStream; |
| |
| /** Stream to write error messages to the android console */ |
| private MessageConsoleStream mAndroidConsoleErrorStream; |
| |
| /** Color used in the error console */ |
| private Color mRed; |
| |
| /** Load status of the SDK. Any access MUST be in a synchronized(mPostLoadProjects) block */ |
| private LoadStatus mSdkLoadedStatus = LoadStatus.LOADING; |
| /** Project to update once the SDK is loaded. |
| * Any access MUST be in a synchronized(mPostLoadProjectsToResolve) block */ |
| private final Set<IJavaProject> mPostLoadProjectsToResolve = Sets.newHashSet(); |
| /** Project to check validity of cache vs actual once the SDK is loaded. |
| * Any access MUST be in a synchronized(mPostLoadProjectsToResolve) block */ |
| private final ArrayList<IJavaProject> mPostLoadProjectsToCheck = new ArrayList<IJavaProject>(); |
| |
| private GlobalProjectMonitor mResourceMonitor; |
| private ArrayList<ITargetChangeListener> mTargetChangeListeners = |
| new ArrayList<ITargetChangeListener>(); |
| |
| /** |
| * This variable indicates that the job inside parseSdkContent() is currently |
| * trying to load the SDK, to avoid re-entrance. |
| * To check whether this succeeds or not, please see {@link #getSdkLoadStatus()}. |
| */ |
| private volatile boolean mParseSdkContentIsRunning; |
| |
| /** |
| * An error handler for checkSdkLocationAndId() that will handle the generated error |
| * or warning message. Each method must return a boolean that will in turn be returned by |
| * checkSdkLocationAndId. |
| */ |
| public static abstract class CheckSdkErrorHandler { |
| |
| public enum Solution { |
| NONE, |
| OPEN_SDK_MANAGER, |
| OPEN_ANDROID_PREFS, |
| OPEN_P2_UPDATE |
| } |
| |
| /** |
| * Handle an error message during sdk location check. Returns whatever |
| * checkSdkLocationAndId() should returns. |
| */ |
| public abstract boolean handleError(Solution solution, String message); |
| |
| /** |
| * Handle a warning message during sdk location check. Returns whatever |
| * checkSdkLocationAndId() should returns. |
| */ |
| public abstract boolean handleWarning(Solution solution, String message); |
| } |
| |
| /** |
| * The constructor |
| */ |
| public AdtPlugin() { |
| 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); |
| |
| // set the default android console. |
| mAndroidConsole = new MessageConsole("Android", null); //$NON-NLS-1$ |
| ConsolePlugin.getDefault().getConsoleManager().addConsoles( |
| new IConsole[] { mAndroidConsole }); |
| |
| // get the stream to write in the android console. |
| mAndroidConsoleStream = mAndroidConsole.newMessageStream(); |
| mAndroidConsoleErrorStream = mAndroidConsole.newMessageStream(); |
| |
| // get the eclipse store |
| IPreferenceStore eclipseStore = getPreferenceStore(); |
| AdtPrefs.init(eclipseStore); |
| |
| // set the listener for the preference change |
| eclipseStore.addPropertyChangeListener(new IPropertyChangeListener() { |
| @Override |
| public void propertyChange(PropertyChangeEvent event) { |
| // load the new preferences |
| AdtPrefs.getPrefs().loadValues(event); |
| |
| // if the SDK changed, we have to do some extra work |
| if (AdtPrefs.PREFS_SDK_DIR.equals(event.getProperty())) { |
| |
| // finally restart adb, in case it's a different version |
| DdmsPlugin.setToolsLocation(getOsAbsoluteAdb(), true /* startAdb */, |
| getOsAbsoluteHprofConv(), getOsAbsoluteTraceview()); |
| |
| // get the SDK location and build id. |
| if (checkSdkLocationAndId()) { |
| // if sdk if valid, reparse it |
| |
| reparseSdk(); |
| } |
| } |
| } |
| }); |
| |
| // load preferences. |
| AdtPrefs.getPrefs().loadValues(null /*event*/); |
| |
| // initialize property-sheet library |
| DesignerPlugin.initialize( |
| this, |
| PLUGIN_ID, |
| CURRENT_PLATFORM == PLATFORM_WINDOWS, |
| CURRENT_PLATFORM == PLATFORM_DARWIN, |
| CURRENT_PLATFORM == PLATFORM_LINUX); |
| |
| // initialize editors |
| startEditors(); |
| |
| // Listen on resource file edits for updates to file inclusion |
| IncludeFinder.start(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext) |
| */ |
| @Override |
| public void stop(BundleContext context) throws Exception { |
| super.stop(context); |
| |
| stopEditors(); |
| IncludeFinder.stop(); |
| |
| DesignerPlugin.dispose(); |
| |
| if (mRed != null) { |
| mRed.dispose(); |
| mRed = null; |
| } |
| |
| synchronized (AdtPlugin.class) { |
| sPlugin = null; |
| } |
| } |
| |
| /** Called when the workbench has been started */ |
| public void workbenchStarted() { |
| // Parse the SDK content. |
| // This is deferred in separate jobs to avoid blocking the bundle start. |
| final boolean isSdkLocationValid = checkSdkLocationAndId(); |
| if (isSdkLocationValid) { |
| // parse the SDK resources. |
| // Wait 2 seconds before starting the job. This leaves some time to the |
| // other bundles to initialize. |
| parseSdkContent(2000 /*milliseconds*/); |
| } |
| |
| Display display = getDisplay(); |
| 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() { |
| mAndroidConsoleErrorStream.setColor(mRed); |
| } |
| }); |
| } |
| |
| /** |
| * Returns the shared instance |
| * |
| * @return the shared instance |
| */ |
| public static synchronized AdtPlugin getDefault() { |
| return sPlugin; |
| } |
| |
| /** |
| * Returns the current display, if any |
| * |
| * @return the display |
| */ |
| @NonNull |
| public static Display getDisplay() { |
| synchronized (AdtPlugin.class) { |
| if (sPlugin != null) { |
| IWorkbench bench = sPlugin.getWorkbench(); |
| if (bench != null) { |
| Display display = bench.getDisplay(); |
| if (display != null) { |
| return display; |
| } |
| } |
| } |
| } |
| |
| Display display = Display.getCurrent(); |
| if (display != null) { |
| return display; |
| } |
| |
| return Display.getDefault(); |
| } |
| |
| /** |
| * Returns the shell, if any |
| * |
| * @return the shell, if any |
| */ |
| @Nullable |
| public static Shell getShell() { |
| Display display = AdtPlugin.getDisplay(); |
| Shell shell = display.getActiveShell(); |
| if (shell == null) { |
| Shell[] shells = display.getShells(); |
| if (shells.length > 0) { |
| shell = shells[0]; |
| } |
| } |
| |
| return shell; |
| } |
| |
| /** Returns the adb path relative to the sdk folder */ |
| public static String getOsRelativeAdb() { |
| return SdkConstants.OS_SDK_PLATFORM_TOOLS_FOLDER + SdkConstants.FN_ADB; |
| } |
| |
| /** Returns the emulator path relative to the sdk folder */ |
| public static String getOsRelativeEmulator() { |
| return SdkConstants.OS_SDK_TOOLS_FOLDER + SdkConstants.FN_EMULATOR; |
| } |
| |
| /** Returns the adb path relative to the sdk folder */ |
| public static String getOsRelativeProguard() { |
| return SdkConstants.OS_SDK_TOOLS_PROGUARD_BIN_FOLDER + SdkConstants.FN_PROGUARD; |
| } |
| |
| /** Returns the absolute adb path */ |
| public static String getOsAbsoluteAdb() { |
| return getOsSdkFolder() + getOsRelativeAdb(); |
| } |
| |
| /** Returns the absolute traceview path */ |
| public static String getOsAbsoluteTraceview() { |
| return getOsSdkFolder() + SdkConstants.OS_SDK_TOOLS_FOLDER + |
| AdtConstants.FN_TRACEVIEW; |
| } |
| |
| /** Returns the absolute emulator path */ |
| public static String getOsAbsoluteEmulator() { |
| return getOsSdkFolder() + getOsRelativeEmulator(); |
| } |
| |
| public static String getOsAbsoluteHprofConv() { |
| return getOsSdkFolder() + SdkConstants.OS_SDK_PLATFORM_TOOLS_FOLDER + |
| AdtConstants.FN_HPROF_CONV; |
| } |
| |
| /** Returns the absolute proguard path */ |
| public static String getOsAbsoluteProguard() { |
| return getOsSdkFolder() + getOsRelativeProguard(); |
| } |
| |
| /** |
| * Returns a Url file path to the javaDoc folder. |
| */ |
| public static String getUrlDoc() { |
| return ProjectHelper.getJavaDocPath( |
| getOsSdkFolder() + AdtConstants.WS_JAVADOC_FOLDER_LEAF); |
| } |
| |
| /** |
| * Returns the SDK folder. |
| * Guaranteed to be terminated by a platform-specific path separator. |
| */ |
| public static synchronized String getOsSdkFolder() { |
| if (sPlugin == null) { |
| return null; |
| } |
| |
| return AdtPrefs.getPrefs().getOsSdkFolder(); |
| } |
| |
| public static String getOsSdkToolsFolder() { |
| return getOsSdkFolder() + SdkConstants.OS_SDK_TOOLS_FOLDER; |
| } |
| |
| /** |
| * Returns an image descriptor for the image file at the given |
| * plug-in relative path |
| * |
| * @param path the path |
| * @return the image descriptor |
| */ |
| public static ImageDescriptor getImageDescriptor(String path) { |
| return imageDescriptorFromPlugin(PLUGIN_ID, path); |
| } |
| |
| /** |
| * Reads the contents of an {@link IFile} and return it as a String |
| * |
| * @param file the file to be read |
| * @return the String read from the file, or null if there was an error |
| */ |
| @SuppressWarnings("resource") // Eclipse doesn't understand Closeables.closeQuietly yet |
| @Nullable |
| public static String readFile(@NonNull IFile file) { |
| InputStream contents = null; |
| InputStreamReader reader = null; |
| try { |
| contents = file.getContents(); |
| String charset = file.getCharset(); |
| reader = new InputStreamReader(contents, charset); |
| return readFile(reader); |
| } catch (CoreException e) { |
| // pass -- ignore files we can't read |
| } catch (IOException e) { |
| // pass -- ignore files we can't read. |
| |
| // Note that IFile.getContents() indicates it throws a CoreException but |
| // experience shows that if the file does not exists it really throws |
| // IOException. |
| // New InputStreamReader() throws UnsupportedEncodingException |
| // which is handled by this IOException catch. |
| |
| } finally { |
| Closeables.closeQuietly(reader); |
| Closeables.closeQuietly(contents); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Reads the contents of an {@link File} and return it as a String |
| * |
| * @param file the file to be read |
| * @return the String read from the file, or null if there was an error |
| */ |
| public static String readFile(File file) { |
| try { |
| return readFile(new FileReader(file)); |
| } catch (FileNotFoundException e) { |
| AdtPlugin.log(e, "Can't read file %1$s", file); //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Writes the given content out to the given {@link File}. The file will be deleted if |
| * it already exists. |
| * |
| * @param file the target file |
| * @param content the content to be written into the file |
| */ |
| public static void writeFile(File file, String content) { |
| if (file.exists()) { |
| file.delete(); |
| } |
| FileWriter fw = null; |
| try { |
| fw = new FileWriter(file); |
| fw.write(content); |
| } catch (IOException e) { |
| AdtPlugin.log(e, null); |
| } finally { |
| if (fw != null) { |
| try { |
| fw.close(); |
| } catch (IOException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns true iff the given file contains the given String. |
| * |
| * @param file the file to look for the string in |
| * @param string the string to be searched for |
| * @return true if the file is found and contains the given string anywhere within it |
| */ |
| @SuppressWarnings("resource") // Closed by streamContains |
| public static boolean fileContains(IFile file, String string) { |
| InputStream contents = null; |
| try { |
| contents = file.getContents(); |
| String charset = file.getCharset(); |
| return streamContains(new InputStreamReader(contents, charset), string); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Can't read file %1$s", file); //$NON-NLS-1$ |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns true iff the given file contains the given String. |
| * |
| * @param file the file to look for the string in |
| * @param string the string to be searched for |
| * @return true if the file is found and contains the given string anywhere within it |
| */ |
| public static boolean fileContains(File file, String string) { |
| try { |
| return streamContains(new FileReader(file), string); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Can't read file %1$s", file); //$NON-NLS-1$ |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns true iff the given input stream contains the given String. |
| * |
| * @param r the stream to look for the string in |
| * @param string the string to be searched for |
| * @return true if the file is found and contains the given string anywhere within it |
| */ |
| public static boolean streamContains(Reader r, String string) { |
| if (string.length() == 0) { |
| return true; |
| } |
| |
| PushbackReader reader = null; |
| try { |
| reader = new PushbackReader(r, string.length()); |
| char first = string.charAt(0); |
| while (true) { |
| int c = reader.read(); |
| if (c == -1) { |
| return false; |
| } else if (c == first) { |
| boolean matches = true; |
| for (int i = 1; i < string.length(); i++) { |
| c = reader.read(); |
| if (c == -1) { |
| return false; |
| } else if (string.charAt(i) != (char)c) { |
| matches = false; |
| // Back up the characters that did not match |
| reader.backup(i-1); |
| break; |
| } |
| } |
| if (matches) { |
| return true; |
| } |
| } |
| } |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Can't read stream"); //$NON-NLS-1$ |
| } finally { |
| try { |
| if (reader != null) { |
| reader.close(); |
| } |
| } catch (IOException e) { |
| AdtPlugin.log(e, "Can't read stream"); //$NON-NLS-1$ |
| } |
| } |
| |
| return false; |
| |
| } |
| |
| /** |
| * A special reader that allows backing up in the input (up to a predefined maximum |
| * number of characters) |
| * <p> |
| * NOTE: This class ONLY works with the {@link #read()} method!! |
| */ |
| private static class PushbackReader extends BufferedReader { |
| /** |
| * Rolling/circular buffer. Can be a char rather than int since we never store EOF |
| * in it. |
| */ |
| private char[] mStorage; |
| |
| /** Points to the head of the queue. When equal to the tail, the queue is empty. */ |
| private int mHead; |
| |
| /** |
| * Points to the tail of the queue. This will move with each read of the actual |
| * wrapped reader, and the characters previous to it in the circular buffer are |
| * the most recently read characters. |
| */ |
| private int mTail; |
| |
| /** |
| * Creates a new reader with a given maximum number of backup characters |
| * |
| * @param reader the reader to wrap |
| * @param max the maximum number of characters to allow rollback for |
| */ |
| public PushbackReader(Reader reader, int max) { |
| super(reader); |
| mStorage = new char[max + 1]; |
| } |
| |
| @Override |
| public int read() throws IOException { |
| // Have we backed up? If so we should serve characters |
| // from the storage |
| if (mHead != mTail) { |
| char c = mStorage[mHead]; |
| mHead = (mHead + 1) % mStorage.length; |
| return c; |
| } |
| assert mHead == mTail; |
| |
| // No backup -- read the next character, but stash it into storage |
| // as well such that we can retrieve it if we must. |
| int c = super.read(); |
| mStorage[mHead] = (char) c; |
| mHead = mTail = (mHead + 1) % mStorage.length; |
| return c; |
| } |
| |
| /** |
| * Backs up the reader a given number of characters. The next N reads will yield |
| * the N most recently read characters prior to this backup. |
| * |
| * @param n the number of characters to be backed up |
| */ |
| public void backup(int n) { |
| if (n >= mStorage.length) { |
| throw new IllegalArgumentException("Exceeded backup limit"); |
| } |
| assert n < mStorage.length; |
| mHead -= n; |
| if (mHead < 0) { |
| mHead += mStorage.length; |
| } |
| } |
| } |
| |
| /** |
| * Reads the contents of a {@link ResourceFile} and returns it as a String |
| * |
| * @param file the file to be read |
| * @return the contents as a String, or null if reading failed |
| */ |
| public static String readFile(ResourceFile file) { |
| InputStream contents = null; |
| try { |
| contents = file.getFile().getContents(); |
| return readFile(new InputStreamReader(contents)); |
| } catch (StreamException e) { |
| // pass -- ignore files we can't read |
| } finally { |
| try { |
| if (contents != null) { |
| contents.close(); |
| } |
| } catch (IOException e) { |
| AdtPlugin.log(e, "Can't read layout file"); //$NON-NLS-1$ |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Reads the contents of a {@link Reader} and return it as a String. This |
| * method will close the input reader. |
| * |
| * @param reader the reader to be read from |
| * @return the String read from reader, or null if there was an error |
| */ |
| public static String readFile(Reader reader) { |
| BufferedReader bufferedReader = null; |
| try { |
| bufferedReader = new BufferedReader(reader); |
| StringBuilder sb = new StringBuilder(2000); |
| while (true) { |
| int c = bufferedReader.read(); |
| if (c == -1) { |
| return sb.toString(); |
| } else { |
| sb.append((char)c); |
| } |
| } |
| } catch (IOException e) { |
| // pass -- ignore files we can't read |
| } finally { |
| try { |
| if (bufferedReader != null) { |
| bufferedReader.close(); |
| } |
| } catch (IOException e) { |
| AdtPlugin.log(e, "Can't read input stream"); //$NON-NLS-1$ |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Reads and returns the content of a text file embedded in the plugin jar |
| * file. |
| * @param filepath the file path to the text file |
| * @return null if the file could not be read |
| */ |
| public static String readEmbeddedTextFile(String filepath) { |
| try { |
| InputStream is = readEmbeddedFileAsStream(filepath); |
| if (is != null) { |
| BufferedReader reader = new BufferedReader(new InputStreamReader(is)); |
| try { |
| String line; |
| StringBuilder total = new StringBuilder(reader.readLine()); |
| while ((line = reader.readLine()) != null) { |
| total.append('\n'); |
| total.append(line); |
| } |
| |
| return total.toString(); |
| } finally { |
| reader.close(); |
| } |
| } |
| } catch (IOException e) { |
| // we'll just return null |
| AdtPlugin.log(e, "Failed to read text file '%s'", filepath); //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Reads and returns the content of a binary file embedded in the plugin jar |
| * file. |
| * @param filepath the file path to the text file |
| * @return null if the file could not be read |
| */ |
| public static byte[] readEmbeddedFile(String filepath) { |
| try { |
| InputStream is = readEmbeddedFileAsStream(filepath); |
| if (is != null) { |
| // create a buffered reader to facilitate reading. |
| BufferedInputStream stream = new BufferedInputStream(is); |
| try { |
| // get the size to read. |
| int avail = stream.available(); |
| |
| // create the buffer and reads it. |
| byte[] buffer = new byte[avail]; |
| stream.read(buffer); |
| |
| // and return. |
| return buffer; |
| } finally { |
| stream.close(); |
| } |
| } |
| } catch (IOException e) { |
| // we'll just return null;. |
| AdtPlugin.log(e, "Failed to read binary file '%s'", filepath); //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Reads and returns the content of a binary file embedded in the plugin jar |
| * file. |
| * @param filepath the file path to the text file |
| * @return null if the file could not be read |
| */ |
| public static InputStream readEmbeddedFileAsStream(String filepath) { |
| // attempt to read an embedded file |
| try { |
| URL url = getEmbeddedFileUrl(AdtConstants.WS_SEP + filepath); |
| if (url != null) { |
| return url.openStream(); |
| } |
| } catch (MalformedURLException e) { |
| // we'll just return null. |
| AdtPlugin.log(e, "Failed to read stream '%s'", filepath); //$NON-NLS-1$ |
| } catch (IOException e) { |
| // we'll just return null;. |
| AdtPlugin.log(e, "Failed to read stream '%s'", filepath); //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the URL of a binary file embedded in the plugin jar file. |
| * @param filepath the file path to the text file |
| * @return null if the file was not found. |
| */ |
| public static URL getEmbeddedFileUrl(String filepath) { |
| Bundle bundle = null; |
| synchronized (AdtPlugin.class) { |
| if (sPlugin != null) { |
| bundle = sPlugin.getBundle(); |
| } else { |
| AdtPlugin.log(IStatus.WARNING, "ADT Plugin is missing"); //$NON-NLS-1$ |
| return null; |
| } |
| } |
| |
| // attempt to get a file to one of the template. |
| String path = filepath; |
| if (!path.startsWith(AdtConstants.WS_SEP)) { |
| path = AdtConstants.WS_SEP + path; |
| } |
| |
| URL url = bundle.getEntry(path); |
| |
| if (url == null) { |
| AdtPlugin.log(IStatus.INFO, "Bundle file URL not found at path '%s'", path); //$NON-NLS-1$ |
| } |
| |
| return url; |
| } |
| |
| /** |
| * Displays an error dialog box. This dialog box is ran asynchronously in the ui thread, |
| * therefore this method can be called from any thread. |
| * @param title The title of the dialog box |
| * @param message The error message |
| */ |
| public final static void displayError(final String title, final String message) { |
| // get the current Display |
| final Display display = getDisplay(); |
| |
| // dialog box only run in ui thread.. |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openError(shell, title, message); |
| } |
| }); |
| } |
| |
| /** |
| * Displays a warning dialog box. This dialog box is ran asynchronously in the ui thread, |
| * therefore this method can be called from any thread. |
| * @param title The title of the dialog box |
| * @param message The warning message |
| */ |
| public final static void displayWarning(final String title, final String message) { |
| // get the current Display |
| final Display display = getDisplay(); |
| |
| // dialog box only run in ui thread.. |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Shell shell = display.getActiveShell(); |
| MessageDialog.openWarning(shell, title, message); |
| } |
| }); |
| } |
| |
| /** |
| * Display a yes/no question dialog box. This dialog is opened synchronously in the ui thread, |
| * therefore this message can be called from any thread. |
| * @param title The title of the dialog box |
| * @param message The error message |
| * @return true if OK was clicked. |
| */ |
| public final static boolean displayPrompt(final String title, final String message) { |
| // get the current Display and Shell |
| final Display display = getDisplay(); |
| |
| // we need to ask the user what he wants to do. |
| final boolean[] result = new boolean[1]; |
| display.syncExec(new Runnable() { |
| @Override |
| public void run() { |
| Shell shell = display.getActiveShell(); |
| result[0] = MessageDialog.openQuestion(shell, title, message); |
| } |
| }); |
| return result[0]; |
| } |
| |
| /** |
| * Logs a message to the default Eclipse log. |
| * |
| * @param severity The severity code. Valid values are: {@link IStatus#OK}, |
| * {@link IStatus#ERROR}, {@link IStatus#INFO}, {@link IStatus#WARNING} or |
| * {@link IStatus#CANCEL}. |
| * @param format The format string, like for {@link String#format(String, Object...)}. |
| * @param args The arguments for the format string, like for |
| * {@link String#format(String, Object...)}. |
| */ |
| public static void log(int severity, String format, Object ... args) { |
| if (format == null) { |
| return; |
| } |
| |
| String message = String.format(format, args); |
| Status status = new Status(severity, PLUGIN_ID, message); |
| |
| if (getDefault() != null) { |
| getDefault().getLog().log(status); |
| } else { |
| // During UnitTests, we generally don't have a plugin object. It's ok |
| // to log to stdout or stderr in this case. |
| (severity < IStatus.ERROR ? System.out : System.err).println(status.toString()); |
| } |
| } |
| |
| /** |
| * Logs an exception to the default Eclipse log. |
| * <p/> |
| * The status severity is always set to ERROR. |
| * |
| * @param exception the exception to log. |
| * @param format The format string, like for {@link String#format(String, Object...)}. |
| * @param args The arguments for the format string, like for |
| * {@link String#format(String, Object...)}. |
| */ |
| public static void log(Throwable exception, String format, Object ... args) { |
| String message = null; |
| if (format != null) { |
| message = String.format(format, args); |
| } else { |
| message = ""; |
| } |
| Status status = new Status(IStatus.ERROR, PLUGIN_ID, message, exception); |
| |
| if (getDefault() != null) { |
| getDefault().getLog().log(status); |
| } else { |
| // During UnitTests, we generally don't have a plugin object. It's ok |
| // to log to stderr in this case. |
| System.err.println(status.toString()); |
| } |
| } |
| |
| /** |
| * This is a mix between log(Throwable) and printErrorToConsole. |
| * <p/> |
| * This logs the exception with an ERROR severity and the given printf-like format message. |
| * The same message is then printed on the Android error console with the associated tag. |
| * |
| * @param exception the exception to log. |
| * @param format The format string, like for {@link String#format(String, Object...)}. |
| * @param args The arguments for the format string, like for |
| * {@link String#format(String, Object...)}. |
| */ |
| public static synchronized void logAndPrintError(Throwable exception, String tag, |
| String format, Object ... args) { |
| if (sPlugin != null) { |
| String message = String.format(format, args); |
| Status status = new Status(IStatus.ERROR, PLUGIN_ID, message, exception); |
| getDefault().getLog().log(status); |
| printToStream(sPlugin.mAndroidConsoleErrorStream, tag, message); |
| showAndroidConsole(); |
| } |
| } |
| |
| /** |
| * Prints one or more error message to the android console. |
| * @param tag A tag to be associated with the message. Can be null. |
| * @param objects the objects to print through their <code>toString</code> method. |
| */ |
| public static synchronized void printErrorToConsole(String tag, Object... objects) { |
| if (sPlugin != null) { |
| printToStream(sPlugin.mAndroidConsoleErrorStream, tag, objects); |
| |
| showAndroidConsole(); |
| } |
| } |
| |
| /** |
| * Prints one or more error message to the android console. |
| * @param objects the objects to print through their <code>toString</code> method. |
| */ |
| public static void printErrorToConsole(Object... objects) { |
| printErrorToConsole((String)null, objects); |
| } |
| |
| /** |
| * Prints one or more error message to the android console. |
| * @param project The project to which the message is associated. Can be null. |
| * @param objects the objects to print through their <code>toString</code> method. |
| */ |
| public static void printErrorToConsole(IProject project, Object... objects) { |
| String tag = project != null ? project.getName() : null; |
| printErrorToConsole(tag, objects); |
| } |
| |
| /** |
| * Prints one or more build messages to the android console, filtered by Build output verbosity. |
| * @param level {@link BuildVerbosity} level of the message. |
| * @param project The project to which the message is associated. Can be null. |
| * @param objects the objects to print through their <code>toString</code> method. |
| * @see BuildVerbosity#ALWAYS |
| * @see BuildVerbosity#NORMAL |
| * @see BuildVerbosity#VERBOSE |
| */ |
| public static synchronized void printBuildToConsole(BuildVerbosity level, IProject project, |
| Object... objects) { |
| if (sPlugin != null) { |
| if (level.getLevel() <= AdtPrefs.getPrefs().getBuildVerbosity().getLevel()) { |
| String tag = project != null ? project.getName() : null; |
| printToStream(sPlugin.mAndroidConsoleStream, tag, objects); |
| } |
| } |
| } |
| |
| /** |
| * Prints one or more message to the android console. |
| * @param tag The tag to be associated with the message. Can be null. |
| * @param objects the objects to print through their <code>toString</code> method. |
| */ |
| public static synchronized void printToConsole(String tag, Object... objects) { |
| if (sPlugin != null) { |
| printToStream(sPlugin.mAndroidConsoleStream, tag, objects); |
| } |
| } |
| |
| /** |
| * Prints one or more message to the android console. |
| * @param project The project to which the message is associated. Can be null. |
| * @param objects the objects to print through their <code>toString</code> method. |
| */ |
| public static void printToConsole(IProject project, Object... objects) { |
| String tag = project != null ? project.getName() : null; |
| printToConsole(tag, objects); |
| } |
| |
| /** Force the display of the android console */ |
| public static void showAndroidConsole() { |
| // first make sure the console is in the workbench |
| EclipseUiHelper.showView(IConsoleConstants.ID_CONSOLE_VIEW, true); |
| |
| // now make sure it's not docked. |
| ConsolePlugin.getDefault().getConsoleManager().showConsoleView( |
| AdtPlugin.getDefault().getAndroidConsole()); |
| } |
| |
| /** |
| * Returns whether the {@link IAndroidTarget}s have been loaded from the SDK. |
| */ |
| public final LoadStatus getSdkLoadStatus() { |
| synchronized (Sdk.getLock()) { |
| return mSdkLoadedStatus; |
| } |
| } |
| |
| /** |
| * Sets the given {@link IJavaProject} to have its target resolved again once the SDK finishes |
| * to load. |
| */ |
| public final void setProjectToResolve(IJavaProject javaProject) { |
| synchronized (Sdk.getLock()) { |
| mPostLoadProjectsToResolve.add(javaProject); |
| } |
| } |
| |
| /** |
| * Sets the given {@link IJavaProject} to have its target checked for consistency |
| * once the SDK finishes to load. This is used if the target is resolved using cached |
| * information while the SDK is loading. |
| */ |
| public final void setProjectToCheck(IJavaProject javaProject) { |
| // only lock on |
| synchronized (Sdk.getLock()) { |
| mPostLoadProjectsToCheck.add(javaProject); |
| } |
| } |
| |
| /** |
| * Checks the location of the SDK in the prefs is valid. |
| * If it is not, display a warning dialog to the user and try to display |
| * some useful link to fix the situation (setup the preferences, perform an |
| * update, etc.) |
| * |
| * @return True if the SDK location points to an SDK. |
| * If false, the user has already been presented with a modal dialog explaining that. |
| */ |
| public boolean checkSdkLocationAndId() { |
| String sdkLocation = AdtPrefs.getPrefs().getOsSdkFolder(); |
| |
| return checkSdkLocationAndId(sdkLocation, new CheckSdkErrorHandler() { |
| private String mTitle = "Android SDK"; |
| |
| /** |
| * Handle an error, which is the case where the check did not find any SDK. |
| * This returns false to {@link AdtPlugin#checkSdkLocationAndId()}. |
| */ |
| @Override |
| public boolean handleError(Solution solution, String message) { |
| displayMessage(solution, message, MessageDialog.ERROR); |
| return false; |
| } |
| |
| /** |
| * Handle an warning, which is the case where the check found an SDK |
| * but it might need to be repaired or is missing an expected component. |
| * |
| * This returns true to {@link AdtPlugin#checkSdkLocationAndId()}. |
| */ |
| @Override |
| public boolean handleWarning(Solution solution, String message) { |
| displayMessage(solution, message, MessageDialog.WARNING); |
| return true; |
| } |
| |
| private void displayMessage( |
| final Solution solution, |
| final String message, |
| final int dialogImageType) { |
| final Display disp = getDisplay(); |
| disp.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Shell shell = disp.getActiveShell(); |
| if (shell == null) { |
| shell = AdtPlugin.getShell(); |
| } |
| if (shell == null) { |
| return; |
| } |
| |
| String customLabel = null; |
| switch(solution) { |
| case OPEN_ANDROID_PREFS: |
| customLabel = "Open Preferences"; |
| break; |
| case OPEN_P2_UPDATE: |
| customLabel = "Check for Updates"; |
| break; |
| case OPEN_SDK_MANAGER: |
| customLabel = "Open SDK Manager"; |
| break; |
| } |
| |
| String btnLabels[] = new String[customLabel == null ? 1 : 2]; |
| btnLabels[0] = customLabel; |
| btnLabels[btnLabels.length - 1] = IDialogConstants.CLOSE_LABEL; |
| |
| MessageDialog dialog = new MessageDialog( |
| shell, // parent |
| mTitle, |
| null, // dialogTitleImage |
| message, |
| dialogImageType, |
| btnLabels, |
| btnLabels.length - 1); |
| int index = dialog.open(); |
| |
| if (customLabel != null && index == 0) { |
| switch(solution) { |
| case OPEN_ANDROID_PREFS: |
| openAndroidPrefs(); |
| break; |
| case OPEN_P2_UPDATE: |
| openP2Update(); |
| break; |
| case OPEN_SDK_MANAGER: |
| openSdkManager(); |
| break; |
| } |
| } |
| } |
| }); |
| } |
| |
| private void openSdkManager() { |
| // Open the standalone external SDK Manager since we know |
| // that ADT on Windows is bound to be locking some SDK folders. |
| // |
| // Also when this is invoked because SdkManagerAction.run() fails, this |
| // test will fail and we'll fallback on using the internal one. |
| if (SdkManagerAction.openExternalSdkManager()) { |
| return; |
| } |
| |
| // Otherwise open the regular SDK Manager bundled within ADT |
| if (!SdkManagerAction.openAdtSdkManager()) { |
| // We failed because the SDK location is undefined. In this case |
| // let's open the preferences instead. |
| openAndroidPrefs(); |
| } |
| } |
| |
| private void openP2Update() { |
| Display disp = getDisplay(); |
| if (disp == null) { |
| return; |
| } |
| disp.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| String cmdId = "org.eclipse.equinox.p2.ui.sdk.update"; //$NON-NLS-1$ |
| IWorkbench wb = PlatformUI.getWorkbench(); |
| if (wb == null) { |
| return; |
| } |
| |
| ICommandService cs = (ICommandService) wb.getService(ICommandService.class); |
| IHandlerService is = (IHandlerService) wb.getService(IHandlerService.class); |
| if (cs == null || is == null) { |
| return; |
| } |
| |
| Command cmd = cs.getCommand(cmdId); |
| if (cmd != null && cmd.isDefined()) { |
| try { |
| is.executeCommand(cmdId, null/*event*/); |
| } catch (Exception ignore) { |
| AdtPlugin.log(ignore, "Failed to execute command %s", cmdId); |
| } |
| } |
| } |
| }); |
| } |
| |
| private void openAndroidPrefs() { |
| PreferenceDialog dialog = PreferencesUtil.createPreferenceDialogOn( |
| getDisplay().getActiveShell(), |
| "com.android.ide.eclipse.preferences.main", //$NON-NLS-1$ preferencePageId |
| null, // displayedIds |
| null); // data |
| dialog.open(); |
| } |
| }); |
| } |
| |
| /** |
| * Internal helper to perform the actual sdk location and id check. |
| * <p/> |
| * This is useful for callers who want to override what happens when the check |
| * fails. Otherwise consider calling {@link #checkSdkLocationAndId()} that will |
| * present a modal dialog to the user in case of failure. |
| * |
| * @param osSdkLocation The sdk directory, an OS path. Can be null. |
| * @param errorHandler An checkSdkErrorHandler that can display a warning or an error. |
| * @return False if there was an error or the result from the errorHandler invocation. |
| */ |
| public boolean checkSdkLocationAndId(@Nullable String osSdkLocation, |
| @NonNull CheckSdkErrorHandler errorHandler) { |
| if (osSdkLocation == null || osSdkLocation.trim().length() == 0) { |
| return errorHandler.handleError( |
| Solution.OPEN_ANDROID_PREFS, |
| "Location of the Android SDK has not been setup in the preferences."); |
| } |
| |
| if (!osSdkLocation.endsWith(File.separator)) { |
| osSdkLocation = osSdkLocation + File.separator; |
| } |
| |
| File osSdkFolder = new File(osSdkLocation); |
| if (osSdkFolder.isDirectory() == false) { |
| return errorHandler.handleError( |
| Solution.OPEN_ANDROID_PREFS, |
| String.format(Messages.Could_Not_Find_Folder, osSdkLocation)); |
| } |
| |
| String osTools = osSdkLocation + SdkConstants.OS_SDK_TOOLS_FOLDER; |
| File toolsFolder = new File(osTools); |
| if (toolsFolder.isDirectory() == false) { |
| return errorHandler.handleError( |
| Solution.OPEN_ANDROID_PREFS, |
| String.format(Messages.Could_Not_Find_Folder_In_SDK, |
| SdkConstants.FD_TOOLS, osSdkLocation)); |
| } |
| |
| // first check the min plug-in requirement as its error message is easier to figure |
| // out for the user |
| if (VersionCheck.checkVersion(osSdkLocation, errorHandler) == false) { |
| return false; |
| } |
| |
| // check that we have both the tools component and the platform-tools component. |
| String platformTools = osSdkLocation + SdkConstants.OS_SDK_PLATFORM_TOOLS_FOLDER; |
| if (checkFolder(platformTools) == false) { |
| return errorHandler.handleWarning( |
| Solution.OPEN_SDK_MANAGER, |
| "SDK Platform Tools component is missing!\n" + |
| "Please use the SDK Manager to install it."); |
| } |
| |
| String tools = osSdkLocation + SdkConstants.OS_SDK_TOOLS_FOLDER; |
| if (checkFolder(tools) == false) { |
| return errorHandler.handleError( |
| Solution.OPEN_SDK_MANAGER, |
| "SDK Tools component is missing!\n" + |
| "Please use the SDK Manager to install it."); |
| } |
| |
| // check the path to various tools we use to make sure nothing is missing. This is |
| // not meant to be exhaustive. |
| String[] filesToCheck = new String[] { |
| osSdkLocation + getOsRelativeAdb(), |
| osSdkLocation + getOsRelativeEmulator() |
| }; |
| for (String file : filesToCheck) { |
| if (checkFile(file) == false) { |
| return errorHandler.handleError( |
| Solution.OPEN_ANDROID_PREFS, |
| String.format(Messages.Could_Not_Find, file)); |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Checks if a path reference a valid existing file. |
| * @param osPath the os path to check. |
| * @return true if the file exists and is, in fact, a file. |
| */ |
| private boolean checkFile(String osPath) { |
| File file = new File(osPath); |
| if (file.isFile() == false) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Checks if a path reference a valid existing folder. |
| * @param osPath the os path to check. |
| * @return true if the folder exists and is, in fact, a folder. |
| */ |
| private boolean checkFolder(String osPath) { |
| File file = new File(osPath); |
| if (file.isDirectory() == false) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Parses the SDK resources. |
| */ |
| private void parseSdkContent(long delay) { |
| // Perform the update in a thread (here an Eclipse runtime job) |
| // since this should never block the caller (especially the start method) |
| Job job = new Job(Messages.AdtPlugin_Android_SDK_Content_Loader) { |
| @SuppressWarnings("unchecked") |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| try { |
| |
| if (mParseSdkContentIsRunning) { |
| return new Status(IStatus.WARNING, PLUGIN_ID, |
| "An Android SDK is already being loaded. Please try again later."); |
| } |
| |
| mParseSdkContentIsRunning = true; |
| |
| SubMonitor progress = SubMonitor.convert(monitor, |
| "Initialize SDK Manager", 100); |
| |
| Sdk sdk = Sdk.loadSdk(AdtPrefs.getPrefs().getOsSdkFolder()); |
| |
| if (sdk != null) { |
| ArrayList<IJavaProject> list = new ArrayList<IJavaProject>(); |
| synchronized (Sdk.getLock()) { |
| mSdkLoadedStatus = LoadStatus.LOADED; |
| |
| progress.setTaskName("Check Projects"); |
| |
| for (IJavaProject javaProject : mPostLoadProjectsToResolve) { |
| IProject iProject = javaProject.getProject(); |
| if (iProject.isOpen()) { |
| // project that have been resolved before the sdk was loaded |
| // will have a ProjectState where the IAndroidTarget is null |
| // so we load the target now that the SDK is loaded. |
| sdk.loadTargetAndBuildTools(Sdk.getProjectState(iProject)); |
| list.add(javaProject); |
| } |
| } |
| |
| // done with this list. |
| mPostLoadProjectsToResolve.clear(); |
| } |
| |
| // check the projects that need checking. |
| // The method modifies the list (it removes the project that |
| // do not need to be resolved again). |
| AndroidClasspathContainerInitializer.checkProjectsCache( |
| mPostLoadProjectsToCheck); |
| |
| list.addAll(mPostLoadProjectsToCheck); |
| |
| // update the project that needs recompiling. |
| if (list.size() > 0) { |
| IJavaProject[] array = list.toArray( |
| new IJavaProject[list.size()]); |
| ProjectHelper.updateProjects(array); |
| } |
| |
| progress.worked(10); |
| } else { |
| // SDK failed to Load! |
| // Sdk#loadSdk() has already displayed an error. |
| synchronized (Sdk.getLock()) { |
| mSdkLoadedStatus = LoadStatus.FAILED; |
| } |
| } |
| |
| // Notify resource changed listeners |
| progress.setTaskName("Refresh UI"); |
| progress.setWorkRemaining(mTargetChangeListeners.size()); |
| |
| // Clone the list before iterating, to avoid ConcurrentModification |
| // exceptions |
| final List<ITargetChangeListener> listeners = |
| (List<ITargetChangeListener>)mTargetChangeListeners.clone(); |
| final SubMonitor progress2 = progress; |
| AdtPlugin.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| for (ITargetChangeListener listener : listeners) { |
| try { |
| listener.onSdkLoaded(); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Failed to update a TargetChangeListener."); //$NON-NLS-1$ |
| } finally { |
| progress2.worked(1); |
| } |
| } |
| } |
| }); |
| } catch (Throwable t) { |
| log(t, "Unknown exception in parseSdkContent."); //$NON-NLS-1$ |
| return new Status(IStatus.ERROR, PLUGIN_ID, |
| "parseSdkContent failed", t); //$NON-NLS-1$ |
| |
| } finally { |
| mParseSdkContentIsRunning = false; |
| if (monitor != null) { |
| monitor.done(); |
| } |
| } |
| |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setPriority(Job.BUILD); // build jobs are run after other interactive jobs |
| job.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| if (delay > 0) { |
| job.schedule(delay); |
| } else { |
| job.schedule(); |
| } |
| } |
| |
| /** Returns the global android console */ |
| public MessageConsole getAndroidConsole() { |
| return mAndroidConsole; |
| } |
| |
| // ----- Methods for Editors ------- |
| |
| public void startEditors() { |
| sAndroidLogoDesc = imageDescriptorFromPlugin(AdtPlugin.PLUGIN_ID, |
| "/icons/android.png"); //$NON-NLS-1$ |
| sAndroidLogo = sAndroidLogoDesc.createImage(); |
| |
| // Add a resource listener to handle compiled resources. |
| IWorkspace ws = ResourcesPlugin.getWorkspace(); |
| mResourceMonitor = GlobalProjectMonitor.startMonitoring(ws); |
| |
| if (mResourceMonitor != null) { |
| try { |
| setupEditors(mResourceMonitor); |
| ResourceManager.setup(mResourceMonitor); |
| LintDeltaProcessor.startListening(mResourceMonitor); |
| } catch (Throwable t) { |
| log(t, "ResourceManager.setup failed"); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| /** |
| * The <code>AbstractUIPlugin</code> implementation of this <code>Plugin</code> |
| * method saves this plug-in's preference and dialog stores and shuts down |
| * its image registry (if they are in use). Subclasses may extend this |
| * method, but must send super <b>last</b>. A try-finally statement should |
| * be used where necessary to ensure that <code>super.shutdown()</code> is |
| * always done. |
| * |
| * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext) |
| */ |
| public void stopEditors() { |
| sAndroidLogo.dispose(); |
| |
| IconFactory.getInstance().dispose(); |
| |
| LintDeltaProcessor.stopListening(mResourceMonitor); |
| |
| // Remove the resource listener that handles compiled resources. |
| IWorkspace ws = ResourcesPlugin.getWorkspace(); |
| GlobalProjectMonitor.stopMonitoring(ws); |
| |
| if (mRed != null) { |
| mRed.dispose(); |
| mRed = null; |
| } |
| } |
| |
| /** |
| * Returns an Image for the small Android logo. |
| * |
| * Callers should not dispose it. |
| */ |
| public static Image getAndroidLogo() { |
| return sAndroidLogo; |
| } |
| |
| /** |
| * Returns an {@link ImageDescriptor} for the small Android logo. |
| * |
| * Callers should not dispose it. |
| */ |
| public static ImageDescriptor getAndroidLogoDesc() { |
| return sAndroidLogoDesc; |
| } |
| |
| /** |
| * Returns the ResourceMonitor object. |
| */ |
| public GlobalProjectMonitor getResourceMonitor() { |
| return mResourceMonitor; |
| } |
| |
| /** |
| * Sets up the editor resource listener. |
| * <p> |
| * The listener handles: |
| * <ul> |
| * <li> Discovering newly created files, and ensuring that if they are in an Android |
| * project, they default to the right XML editor. |
| * <li> Discovering deleted files, and closing the corresponding editors if necessary. |
| * This is only done for XML files, since other editors such as Java editors handles |
| * it on their own. |
| * <ul> |
| * |
| * This is called by the {@link AdtPlugin} during initialization. |
| * |
| * @param monitor The main Resource Monitor object. |
| */ |
| public void setupEditors(GlobalProjectMonitor monitor) { |
| monitor.addFileListener(new IFileListener() { |
| @Override |
| public void fileChanged(@NonNull IFile file, @NonNull IMarkerDelta[] markerDeltas, |
| int kind, @Nullable String extension, int flags, boolean isAndroidProject) { |
| if (!isAndroidProject) { |
| return; |
| } |
| if (flags == IResourceDelta.MARKERS || !SdkConstants.EXT_XML.equals(extension)) { |
| // ONLY the markers changed, or not XML file: not relevant to this listener |
| return; |
| } |
| |
| if (kind == IResourceDelta.REMOVED) { |
| AdtUtils.closeEditors(file, false /*save*/); |
| return; |
| } |
| |
| // The resources files must have a file path similar to |
| // project/res/.../*.xml |
| // There is no support for sub folders, so the segment count must be 4 |
| if (file.getFullPath().segmentCount() == 4) { |
| // check if we are inside the res folder. |
| String segment = file.getFullPath().segment(1); |
| if (segment.equalsIgnoreCase(SdkConstants.FD_RESOURCES)) { |
| // we are inside a res/ folder, get the ResourceFolderType of the |
| // parent folder. |
| String[] folderSegments = file.getParent().getName().split( |
| SdkConstants.RES_QUALIFIER_SEP); |
| |
| // get the enum for the resource type. |
| ResourceFolderType type = ResourceFolderType.getTypeByName( |
| folderSegments[0]); |
| |
| if (type != null) { |
| if (kind == IResourceDelta.ADDED) { |
| // A new file {@code /res/type-config/some.xml} was added. |
| // All the /res XML files are handled by the same common editor now. |
| IDE.setDefaultEditor(file, CommonXmlEditor.ID); |
| } |
| } else { |
| // if the res folder is null, this means the name is invalid, |
| // in this case we remove whatever android editors that was set |
| // as the default editor. |
| IEditorDescriptor desc = IDE.getDefaultEditor(file); |
| String editorId = desc.getId(); |
| if (editorId.startsWith(AdtConstants.EDITORS_NAMESPACE)) { |
| // reset the default editor. |
| IDE.setDefaultEditor(file, null); |
| } |
| } |
| } |
| } |
| } |
| }, IResourceDelta.ADDED | IResourceDelta.REMOVED); |
| |
| monitor.addProjectListener(new IProjectListener() { |
| @Override |
| public void projectClosed(IProject project) { |
| // Close any editors referencing this project |
| AdtUtils.closeEditors(project, true /*save*/); |
| } |
| |
| @Override |
| public void projectDeleted(IProject project) { |
| // Close any editors referencing this project |
| AdtUtils.closeEditors(project, false /*save*/); |
| } |
| |
| @Override |
| public void projectOpenedWithWorkspace(IProject project) { |
| } |
| |
| @Override |
| public void allProjectsOpenedWithWorkspace() { |
| } |
| |
| @Override |
| public void projectOpened(IProject project) { |
| } |
| |
| @Override |
| public void projectRenamed(IProject project, IPath from) { |
| } |
| }); |
| } |
| |
| /** |
| * Adds a new {@link ITargetChangeListener} to be notified when a new SDK is loaded, or when |
| * a project has its target changed. |
| */ |
| public void addTargetListener(ITargetChangeListener listener) { |
| mTargetChangeListeners.add(listener); |
| } |
| |
| /** |
| * Removes an existing {@link ITargetChangeListener}. |
| * @see #addTargetListener(ITargetChangeListener) |
| */ |
| public void removeTargetListener(ITargetChangeListener listener) { |
| mTargetChangeListeners.remove(listener); |
| } |
| |
| /** |
| * Updates all the {@link ITargetChangeListener}s that a target has changed for a given project. |
| * <p/>Only editors related to that project should reload. |
| */ |
| @SuppressWarnings("unchecked") |
| public void updateTargetListeners(final IProject project) { |
| final List<ITargetChangeListener> listeners = |
| (List<ITargetChangeListener>)mTargetChangeListeners.clone(); |
| |
| AdtPlugin.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| for (ITargetChangeListener listener : listeners) { |
| try { |
| listener.onProjectTargetChange(project); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Failed to update a TargetChangeListener."); //$NON-NLS-1$ |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Updates all the {@link ITargetChangeListener}s that a target data was loaded. |
| * <p/>Only editors related to a project using this target should reload. |
| */ |
| @SuppressWarnings("unchecked") |
| public void updateTargetListeners(final IAndroidTarget target) { |
| final List<ITargetChangeListener> listeners = |
| (List<ITargetChangeListener>)mTargetChangeListeners.clone(); |
| |
| Display display = AdtPlugin.getDisplay(); |
| if (display == null || display.isDisposed()) { |
| return; |
| } |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| for (ITargetChangeListener listener : listeners) { |
| try { |
| listener.onTargetLoaded(target); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Failed to update a TargetChangeListener."); //$NON-NLS-1$ |
| } |
| } |
| } |
| }); |
| } |
| |
| public static synchronized OutputStream getOutStream() { |
| return sPlugin.mAndroidConsoleStream; |
| } |
| |
| public static synchronized OutputStream getErrorStream() { |
| return sPlugin.mAndroidConsoleErrorStream; |
| } |
| |
| /** |
| * Sets the named persistent property for the given file to the given value |
| * |
| * @param file the file to associate the property with |
| * @param qname the name of the property |
| * @param value the new value, or null to clear the property |
| */ |
| public static void setFileProperty(IFile file, QualifiedName qname, String value) { |
| try { |
| file.setPersistentProperty(qname, value); |
| } catch (CoreException e) { |
| log(e, "Cannot set property %1$s to %2$s", qname, value); |
| } |
| } |
| |
| /** |
| * Gets the named persistent file property from the given file |
| * |
| * @param file the file to look up properties for |
| * @param qname the name of the property to look up |
| * @return the property value, or null |
| */ |
| public static String getFileProperty(IFile file, QualifiedName qname) { |
| try { |
| return file.getPersistentProperty(qname); |
| } catch (CoreException e) { |
| log(e, "Cannot get property %1$s", qname); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Conditionally reparses the content of the SDK if it has changed on-disk |
| * and updates opened projects. |
| * <p/> |
| * The operation is asynchronous and happens in a background eclipse job. |
| * <p/> |
| * This operation is called in multiple places and should be reasonably |
| * cheap and conservative. The goal is to automatically refresh the SDK |
| * when it is obvious it has changed so when not sure the code should |
| * tend to not reload and avoid reloading too often (which is an expensive |
| * operation that has a lot of user impact.) |
| */ |
| public void refreshSdk() { |
| // SDK can't have changed if we haven't loaded it yet. |
| final Sdk sdk = Sdk.getCurrent(); |
| if (sdk == null) { |
| return; |
| } |
| |
| Job job = new Job("Check Android SDK") { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| // SDK has changed if its location path is different. |
| File location = sdk.getSdkFileLocation(); |
| boolean changed = location == null || !location.isDirectory(); |
| |
| if (!changed) { |
| assert location != null; |
| File prefLocation = new File(AdtPrefs.getPrefs().getOsSdkFolder()); |
| changed = !location.equals(prefLocation); |
| |
| if (changed) { |
| // Basic file path comparison indicates they are not the same. |
| // Let's dig a bit deeper. |
| try { |
| location = location.getCanonicalFile(); |
| prefLocation = prefLocation.getCanonicalFile(); |
| changed = !location.equals(prefLocation); |
| } catch (IOException ignore) { |
| // There's no real reason for the canonicalization to fail |
| // if the paths map to actual directories. And if they don't |
| // this should have been caught above. |
| } |
| } |
| } |
| |
| if (!changed) { |
| // Check whether the target directories has potentially changed. |
| changed = sdk.haveTargetsChanged(); |
| } |
| |
| if (changed) { |
| monitor.setTaskName("Reload Android SDK"); |
| reparseSdk(); |
| } |
| |
| monitor.done(); |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| job.setPriority(Job.SHORT); // a short background job, not interactive. |
| job.schedule(); |
| } |
| |
| /** |
| * Reparses the content of the SDK and updates opened projects. |
| * The operation is asynchronous and happens in a background eclipse job. |
| * <p/> |
| * This reloads the SDK all the time. To only perform this when it has potentially |
| * changed, call {@link #refreshSdk()} instead. |
| */ |
| public void reparseSdk() { |
| // add all the opened Android projects to the list of projects to be updated |
| // after the SDK is reloaded |
| synchronized (Sdk.getLock()) { |
| // get the project to refresh. |
| IJavaProject[] androidProjects = BaseProjectHelper.getAndroidProjects(null /*filter*/); |
| mPostLoadProjectsToResolve.addAll(Arrays.asList(androidProjects)); |
| } |
| |
| // parse the SDK resources at the new location |
| parseSdkContent(0 /*immediately*/); |
| } |
| |
| /** |
| * Prints messages, 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 objects The objects to print through their toString() method (or directly for |
| * {@link String} objects. |
| */ |
| public static synchronized void printToStream(MessageConsoleStream stream, String tag, |
| Object... objects) { |
| String dateTag = AndroidPrintStream.getMessageTag(tag); |
| |
| for (Object obj : objects) { |
| stream.print(dateTag); |
| stream.print(" "); //$NON-NLS-1$ |
| if (obj instanceof String) { |
| stream.println((String)obj); |
| } else if (obj == null) { |
| stream.println("(null)"); //$NON-NLS-1$ |
| } else { |
| stream.println(obj.toString()); |
| } |
| } |
| } |
| |
| // --------- ILogger methods ----------- |
| |
| @Override |
| public void error(@Nullable Throwable t, @Nullable String format, Object... args) { |
| if (t != null) { |
| log(t, format, args); |
| } else { |
| log(IStatus.ERROR, format, args); |
| } |
| } |
| |
| @Override |
| public void info(@NonNull String format, Object... args) { |
| log(IStatus.INFO, format, args); |
| } |
| |
| @Override |
| public void verbose(@NonNull String format, Object... args) { |
| log(IStatus.INFO, format, args); |
| } |
| |
| @Override |
| public void warning(@NonNull String format, Object... args) { |
| log(IStatus.WARNING, format, args); |
| } |
| |
| /** |
| * Opens the given URL in a browser tab |
| * |
| * @param url the URL to open in a browser |
| */ |
| public static void openUrl(URL url) { |
| IWorkbenchBrowserSupport support = PlatformUI.getWorkbench().getBrowserSupport(); |
| IWebBrowser browser; |
| try { |
| browser = support.createBrowser(PLUGIN_ID); |
| browser.openURL(url); |
| } catch (PartInitException e) { |
| log(e, null); |
| } |
| } |
| |
| /** |
| * Opens a Java class for the given fully qualified class name |
| * |
| * @param project the project containing the class |
| * @param fqcn the fully qualified class name of the class to be opened |
| * @return true if the class was opened, false otherwise |
| */ |
| public static boolean openJavaClass(IProject project, String fqcn) { |
| if (fqcn == null) { |
| return false; |
| } |
| |
| // Handle inner classes |
| if (fqcn.indexOf('$') != -1) { |
| fqcn = fqcn.replaceAll("\\$", "."); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| try { |
| if (project.hasNature(JavaCore.NATURE_ID)) { |
| IJavaProject javaProject = JavaCore.create(project); |
| IJavaElement result = javaProject.findType(fqcn); |
| if (result != null) { |
| return JavaUI.openInEditor(result) != null; |
| } |
| } |
| } catch (Throwable e) { |
| log(e, "Can't open class %1$s", fqcn); //$NON-NLS-1$ |
| } |
| |
| return false; |
| } |
| |
| /** |
| * For a stack trace entry, specifying a class, method, and optionally |
| * fileName and line number, open the corresponding line in the editor. |
| * |
| * @param fqcn the fully qualified name of the class |
| * @param method the method name |
| * @param fileName the file name, or null |
| * @param lineNumber the line number or -1 |
| * @return true if the target location could be opened, false otherwise |
| */ |
| public static boolean openStackTraceLine(@Nullable String fqcn, |
| @Nullable String method, @Nullable String fileName, int lineNumber) { |
| return new SourceRevealer().revealMethod(fqcn + '.' + method, fileName, lineNumber, null); |
| } |
| |
| /** |
| * Opens the given file and shows the given (optional) region in the editor (or |
| * if no region is specified, opens the editor tab.) |
| * |
| * @param file the file to be opened |
| * @param region an optional region which if set will be selected and shown to the |
| * user |
| * @throws PartInitException if something goes wrong |
| */ |
| public static void openFile(IFile file, IRegion region) throws PartInitException { |
| openFile(file, region, true); |
| } |
| |
| // TODO: Make an openEditor which does the above, and make the above pass false for showEditor |
| |
| /** |
| * Opens the given file and shows the given (optional) region |
| * |
| * @param file the file to be opened |
| * @param region an optional region which if set will be selected and shown to the |
| * user |
| * @param showEditorTab if true, front the editor tab after opening the file |
| * @return the editor that was opened, or null if no editor was opened |
| * @throws PartInitException if something goes wrong |
| */ |
| public static IEditorPart openFile(IFile file, IRegion region, boolean showEditorTab) |
| throws PartInitException { |
| IWorkbenchPage page = AdtUtils.getActiveWorkbenchPage(); |
| if (page == null) { |
| return null; |
| } |
| IEditorPart targetEditor = IDE.openEditor(page, file, true); |
| if (targetEditor instanceof AndroidXmlEditor) { |
| AndroidXmlEditor editor = (AndroidXmlEditor) targetEditor; |
| if (region != null) { |
| editor.show(region.getOffset(), region.getLength(), showEditorTab); |
| } else if (showEditorTab) { |
| editor.setActivePage(AndroidXmlEditor.TEXT_EDITOR_ID); |
| } |
| } else if (targetEditor instanceof AbstractTextEditor) { |
| AbstractTextEditor editor = (AbstractTextEditor) targetEditor; |
| if (region != null) { |
| editor.setHighlightRange(region.getOffset(), region.getLength(), |
| true /* moveCursor*/); |
| } |
| } |
| |
| return targetEditor; |
| } |
| } |
