diff options
4 files changed, 541 insertions, 25 deletions
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml b/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml index e6a5e82..4dfeadc 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml +++ b/eclipse/plugins/com.android.ide.eclipse.adt/plugin.xml @@ -411,6 +411,15 @@ </classpathContainerInitializer> </extension> <extension + point="org.eclipse.jdt.ui.classpathContainerPage"> + <classpathContainerPage + name="Android Classpath Container" + class="com.android.ide.eclipse.adt.internal.project.AndroidClasspathContainerPage" + id="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"> + </classpathContainerPage> + </extension> + + <extension point="org.eclipse.ui.exportWizards"> <category id="com.android.ide.eclipse.wizards.category" @@ -681,10 +690,18 @@ modes="run,debug" name="Android JUnit Test" public="true" - sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector" + sourceLocatorId="com.android.ide.eclipse.adt.internal.sourcelookup.AdtSourceLookupDirector" sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"> </launchConfigurationType> </extension> + <extension point="org.eclipse.debug.core.sourceLocators"> + <sourceLocator + id="com.android.ide.eclipse.adt.internal.sourcelookup.AdtSourceLookupDirector" + class="com.android.ide.eclipse.adt.internal.sourcelookup.AdtSourceLookupDirector" + name="%sourceLocator.name"> + </sourceLocator> + </extension> + <extension point="org.eclipse.debug.ui.launchConfigurationTypeImages"> <launchConfigurationTypeImage diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerInitializer.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerInitializer.java index 402e24a..50df52a 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerInitializer.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerInitializer.java @@ -21,18 +21,24 @@ import com.android.ide.eclipse.adt.AndroidConstants; import com.android.ide.eclipse.adt.internal.sdk.LoadStatus; import com.android.ide.eclipse.adt.internal.sdk.ProjectState; import com.android.ide.eclipse.adt.internal.sdk.Sdk; +import com.android.sdklib.AndroidVersion; import com.android.sdklib.IAndroidTarget; import com.android.sdklib.IAndroidTarget.IOptionalLibrary; +import com.android.sdklib.SdkConstants; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.FileLocator; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jdt.core.ClasspathContainerInitializer; @@ -40,13 +46,18 @@ import org.eclipse.jdt.core.IAccessRule; import org.eclipse.jdt.core.IClasspathAttribute; import org.eclipse.jdt.core.IClasspathContainer; import org.eclipse.jdt.core.IClasspathEntry; +import org.eclipse.jdt.core.IJavaModel; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; +import org.osgi.framework.Bundle; import java.io.File; +import java.io.IOException; +import java.io.InputStream; import java.net.URI; import java.net.URISyntaxException; +import java.net.URL; import java.util.ArrayList; import java.util.HashSet; import java.util.regex.Pattern; @@ -56,8 +67,21 @@ import java.util.regex.Pattern; * {@link IProject}s. This removes the hard-coded path to the android.jar. */ public class AndroidClasspathContainerInitializer extends ClasspathContainerInitializer { + + public static final String SOURCES_ZIP = "/sources.zip"; //$NON-NLS-1$ + + public static final String COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE = + "com.android.ide.eclipse.source"; //$NON-NLS-1$ + + private static final String ANDROID_API_REFERENCE = + "http://developer.android.com/reference/"; //$NON-NLS-1$ + + private final static String PROPERTY_ANDROID_API = "androidApi"; //$NON-NLS-1$ + + private final static String PROPERTY_ANDROID_SOURCE = "androidSource"; //$NON-NLS-1$ + /** The container id for the android framework jar file */ - private final static String CONTAINER_ID = + public final static String CONTAINER_ID = "com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"; //$NON-NLS-1$ /** path separator to store multiple paths in a single property. This is guaranteed to not @@ -155,6 +179,7 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit String markerMessage = null; boolean outputToConsole = true; + IAndroidTarget target = null; try { AdtPlugin plugin = AdtPlugin.getDefault(); @@ -170,7 +195,7 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit "Project has no default.properties file! Edit the project properties to set one."); } else { // this might be null if the sdk is not yet loaded. - IAndroidTarget target = state.getTarget(); + target = state.getTarget(); // if we are loaded and the target is non null, we create a valid // ClassPathContainer @@ -207,7 +232,7 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit // this is the case where there is a hashString but the SDK is not yet // loaded and therefore we can't get the target yet. // We check if there is a cache of the needed information. - AndroidClasspathContainer container = getContainerFromCache(iProject); + AndroidClasspathContainer container = getContainerFromCache(iProject, target); if (container == null) { // either the cache was wrong (ie folder does not exists anymore), or @@ -343,7 +368,7 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit String[] paths = getTargetPaths(target); // create the classpath entry from the paths - IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths); + IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths, target); // paths now contains all the path required to recreate the IClasspathEntry with no // target info. We encode them in a single string, with each path separated by @@ -364,7 +389,8 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit /** * Generates an {@link AndroidClasspathContainer} from the project cache, if possible. */ - private static AndroidClasspathContainer getContainerFromCache(IProject project) { + private static AndroidClasspathContainer getContainerFromCache(IProject project, + IAndroidTarget target) { // get the cached info from the project persistent properties. String cache = ProjectHelper.loadStringProperty(project, PROPERTY_CONTAINER_CACHE); String targetNameCache = ProjectHelper.loadStringProperty(project, PROPERTY_TARGET_NAME); @@ -423,7 +449,7 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit return null; } - IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths); + IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths, target); return new AndroidClasspathContainer(entries, new Path(CONTAINER_ID), targetNameCache); @@ -433,30 +459,90 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit * Generates an array of {@link IClasspathEntry} from a set of paths. * @see #getTargetPaths(IAndroidTarget) */ - private static IClasspathEntry[] createClasspathEntriesFromPaths(String[] paths) { + private static IClasspathEntry[] createClasspathEntriesFromPaths(String[] paths, + IAndroidTarget target) { ArrayList<IClasspathEntry> list = new ArrayList<IClasspathEntry>(); // First, we create the IClasspathEntry for the framework. // now add the android framework to the class path. // create the path object. - IPath android_lib = new Path(paths[CACHE_INDEX_JAR]); - IPath android_src = new Path(paths[CACHE_INDEX_SRC]); + IPath androidLib = new Path(paths[CACHE_INDEX_JAR]); + + IPath androidSrc = null; + String androidSrcOsPath = null; + IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); + if (target != null) { + androidSrcOsPath = + ProjectHelper.loadStringProperty(root, getAndroidSourceProperty(target)); + } + if (androidSrcOsPath != null && androidSrcOsPath.trim().length() > 0) { + androidSrc = new Path(androidSrcOsPath); + } + if (androidSrc == null) { + androidSrc = new Path(paths[CACHE_INDEX_SRC]); + File androidSrcFile = new File(paths[CACHE_INDEX_SRC]); + if (!androidSrcFile.isDirectory()) { + androidSrc = null; + } + } - // create the java doc link. - IClasspathAttribute cpAttribute = JavaCore.newClasspathAttribute( - IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, - paths[CACHE_INDEX_DOCS_URI]); + if (androidSrc == null && target != null) { + Bundle bundle = getSourceBundle(); + + if (bundle != null) { + AndroidVersion version = target.getVersion(); + String apiString = version.getApiString(); + String sourcePath = apiString + SOURCES_ZIP; + URL sourceURL = bundle.getEntry(sourcePath); + if (sourceURL != null) { + URL url = null; + try { + url = FileLocator.resolve(sourceURL); + } catch (IOException ignore) { + } + if (url != null) { + androidSrcOsPath = url.getFile(); + if (new File(androidSrcOsPath).isFile()) { + androidSrc = new Path(androidSrcOsPath); + } + } + } + } + } - // create the access rule to restrict access to classes in com.android.internal - IAccessRule accessRule = JavaCore.newAccessRule( - new Path("com/android/internal/**"), //$NON-NLS-1$ + // create the java doc link. + String androidApiURL = ProjectHelper.loadStringProperty(root, PROPERTY_ANDROID_API); + String apiURL = null; + if (androidApiURL != null) { + apiURL = androidApiURL; + } else { + if (testURL(androidApiURL)) { + apiURL = androidApiURL; + } else if (testURL(paths[CACHE_INDEX_DOCS_URI])) { + apiURL = paths[CACHE_INDEX_DOCS_URI]; + } else if (testURL(ANDROID_API_REFERENCE)) { + apiURL = ANDROID_API_REFERENCE; + } + } + IClasspathAttribute[] attributes = null; + if (apiURL != null) { + + IClasspathAttribute cpAttribute = JavaCore.newClasspathAttribute( + IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, apiURL); + attributes = new IClasspathAttribute[] { + cpAttribute + }; + } + // create the access rule to restrict access to classes in + // com.android.internal + IAccessRule accessRule = JavaCore.newAccessRule(new Path("com/android/internal/**"), //$NON-NLS-1$ IAccessRule.K_NON_ACCESSIBLE); - IClasspathEntry frameworkClasspathEntry = JavaCore.newLibraryEntry(android_lib, - android_src, // source attachment path - null, // default source attachment root path. + IClasspathEntry frameworkClasspathEntry = JavaCore.newLibraryEntry(androidLib, + androidSrc, // source attachment path + null, // default source attachment root path. new IAccessRule[] { accessRule }, - new IClasspathAttribute[] { cpAttribute }, + attributes, false // not exported. ); @@ -469,12 +555,11 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit while (i < paths.length) { Path jarPath = new Path(paths[i++]); - IClasspathAttribute[] attributes = null; + attributes = null; if (docPath.length() > 0) { attributes = new IClasspathAttribute[] { - JavaCore.newClasspathAttribute( - IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, - docPath) + JavaCore.newClasspathAttribute( + IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, docPath) }; } @@ -490,9 +575,51 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit } } + if (apiURL != null) { + ProjectHelper.saveStringProperty(root, PROPERTY_ANDROID_API, apiURL); + } + if (androidSrc != null && target != null) { + ProjectHelper.saveStringProperty(root, getAndroidSourceProperty(target), + androidSrc.toOSString()); + } return list.toArray(new IClasspathEntry[list.size()]); } + private static Bundle getSourceBundle() { + String bundleId = System.getProperty(COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE, + COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE); + Bundle bundle = Platform.getBundle(bundleId); + return bundle; + } + + private static String getAndroidSourceProperty(IAndroidTarget target) { + if (target == null) { + return null; + } + String androidSourceProperty = PROPERTY_ANDROID_SOURCE + "_" + + target.getVersion().getApiString(); + return androidSourceProperty; + } + + private static boolean testURL(String androidApiURL) { + boolean valid = false; + InputStream is = null; + try { + URL testURL = new URL(androidApiURL); + is = testURL.openStream(); + valid = true; + } catch (Exception ignore) { + } finally { + if (is != null) { + try { + is.close(); + } catch (IOException ignore) { + } + } + } + return valid; + } + /** * Checks the projects' caches. If the cache was valid, the project is removed from the list. * @param projects the list of projects to check. @@ -651,4 +778,86 @@ public class AndroidClasspathContainerInitializer extends ClasspathContainerInit return paths.toArray(new String[paths.size()]); } + + @Override + public boolean canUpdateClasspathContainer(IPath containerPath, IJavaProject project) { + return true; + } + + @Override + public void requestClasspathContainerUpdate(IPath containerPath, IJavaProject project, + IClasspathContainer containerSuggestion) throws CoreException { + AdtPlugin plugin = AdtPlugin.getDefault(); + + synchronized (Sdk.getLock()) { + boolean sdkIsLoaded = plugin.getSdkLoadStatus() == LoadStatus.LOADED; + + // check if the project has a valid target. + IAndroidTarget target = null; + if (sdkIsLoaded) { + target = Sdk.getCurrent().getTarget(project.getProject()); + } + if (sdkIsLoaded && target != null) { + String[] paths = getTargetPaths(target); + IPath android_lib = new Path(paths[CACHE_INDEX_JAR]); + IClasspathEntry[] entries = containerSuggestion.getClasspathEntries(); + for (int i = 0; i < entries.length; i++) { + IClasspathEntry entry = entries[i]; + if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { + IPath entryPath = entry.getPath(); + + if (entryPath != null) { + if (entryPath.equals(android_lib)) { + IPath entrySrcPath = entry.getSourceAttachmentPath(); + IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); + if (entrySrcPath != null) { + ProjectHelper.saveStringProperty(root, + getAndroidSourceProperty(target), + entrySrcPath.toString()); + } else { + ProjectHelper.saveStringProperty(root, + getAndroidSourceProperty(target), null); + } + IClasspathAttribute[] extraAttributtes = entry.getExtraAttributes(); + for (int j = 0; j < extraAttributtes.length; j++) { + IClasspathAttribute extraAttribute = extraAttributtes[j]; + if (IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME + .equals(extraAttribute.getName())) { + ProjectHelper.saveStringProperty(root, + PROPERTY_ANDROID_API, extraAttribute.getValue()); + + } + } + } + } + } + } + rebindClasspathEntries(project.getJavaModel(), containerPath); + } + } + } + + private static void rebindClasspathEntries(IJavaModel model, IPath containerPath) + throws JavaModelException { + ArrayList affectedProjects = new ArrayList(); + + IJavaProject[] projects = model.getJavaProjects(); + for (int i = 0; i < projects.length; i++) { + IJavaProject project = projects[i]; + IClasspathEntry[] entries = project.getRawClasspath(); + for (int k = 0; k < entries.length; k++) { + IClasspathEntry curr = entries[k]; + if (curr.getEntryKind() == IClasspathEntry.CPE_CONTAINER + && containerPath.equals(curr.getPath())) { + affectedProjects.add(project); + } + } + } + if (!affectedProjects.isEmpty()) { + IJavaProject[] affected = (IJavaProject[]) affectedProjects + .toArray(new IJavaProject[affectedProjects.size()]); + updateProjects(affected); + } + } + } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerPage.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerPage.java new file mode 100644 index 0000000..4641c22 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/project/AndroidClasspathContainerPage.java @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2010 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.internal.project; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Path; +import org.eclipse.jdt.core.IClasspathEntry; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.internal.ui.dialogs.StatusInfo; +import org.eclipse.jdt.internal.ui.dialogs.StatusUtil; +import org.eclipse.jdt.ui.wizards.IClasspathContainerPage; +import org.eclipse.jdt.ui.wizards.IClasspathContainerPageExtension; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Combo; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Label; + +import java.util.Arrays; + +public class AndroidClasspathContainerPage extends WizardPage implements IClasspathContainerPage, + IClasspathContainerPageExtension { + + private IProject mOwnerProject; + + private String mLibsProjectName; + + private Combo mProjectsCombo; + + private IStatus mCurrStatus; + + private boolean mPageVisible; + + public AndroidClasspathContainerPage() { + super("AndroidClasspathContainerPage"); //$NON-NLS-1$ + mPageVisible = false; + mCurrStatus = new StatusInfo(); + setTitle("Android Libraries"); + setDescription("This container manages classpath entries for Android container"); + } + + public IClasspathEntry getSelection() { + IPath path = new Path(AndroidClasspathContainerInitializer.CONTAINER_ID); + + final int index = this.mProjectsCombo.getSelectionIndex(); + if (index != -1) { + final String selectedProjectName = this.mProjectsCombo.getItem(index); + + if (this.mOwnerProject == null + || !selectedProjectName.equals(this.mOwnerProject.getName())) { + path = path.append(selectedProjectName); + } + } + + return JavaCore.newContainerEntry(path); + } + + public void setSelection(final IClasspathEntry cpentry) { + final IPath path = cpentry == null ? null : cpentry.getPath(); + + if (path == null || path.segmentCount() == 1) { + if (this.mOwnerProject != null) { + this.mLibsProjectName = this.mOwnerProject.getName(); + } + } else { + this.mLibsProjectName = path.segment(1); + } + } + + public void createControl(final Composite parent) { + final Composite composite = new Composite(parent, SWT.NONE); + composite.setLayout(new GridLayout(2, false)); + + final Label label = new Label(composite, SWT.NONE); + label.setText("Project:"); + + final String[] androidProjects = getAndroidProjects(); + + this.mProjectsCombo = new Combo(composite, SWT.READ_ONLY); + this.mProjectsCombo.setItems(androidProjects); + + final int index; + + if (this.mOwnerProject != null) { + index = indexOf(androidProjects, this.mLibsProjectName); + } else { + if (this.mProjectsCombo.getItemCount() > 0) { + index = 0; + } else { + index = -1; + } + } + + if (index != -1) { + this.mProjectsCombo.select(index); + } + + final GridData gd = new GridData(); + gd.grabExcessHorizontalSpace = true; + gd.minimumWidth = 100; + + this.mProjectsCombo.setLayoutData(gd); + + setControl(composite); + } + + public boolean finish() { + return true; + } + + @Override + public void setVisible(boolean visible) { + super.setVisible(visible); + mPageVisible = visible; + // policy: wizards are not allowed to come up with an error message + if (visible && mCurrStatus.matches(IStatus.ERROR)) { + StatusInfo status = new StatusInfo(); + status.setError(""); //$NON-NLS-1$ + mCurrStatus = status; + } + updateStatus(mCurrStatus); + } + + /** + * Updates the status line and the OK button according to the given status + * + * @param status status to apply + */ + protected void updateStatus(IStatus status) { + mCurrStatus = status; + setPageComplete(!status.matches(IStatus.ERROR)); + if (mPageVisible) { + StatusUtil.applyToStatusLine(this, status); + } + } + + /** + * Updates the status line and the OK button according to the status + * evaluate from an array of status. The most severe error is taken. In case + * that two status with the same severity exists, the status with lower + * index is taken. + * + * @param status the array of status + */ + protected void updateStatus(IStatus[] status) { + updateStatus(StatusUtil.getMostSevere(status)); + } + + public void initialize(final IJavaProject project, final IClasspathEntry[] currentEntries) { + this.mOwnerProject = (project == null ? null : project.getProject()); + } + + private static String[] getAndroidProjects() { + IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); + final String[] names = new String[projects.length]; + for (int i = 0; i < projects.length; i++) { + names[i] = projects[i].getName(); + } + Arrays.sort(names); + return names; + } + + private static int indexOf(final String[] array, final String str) { + for (int i = 0; i < array.length; i++) { + if (array[i].equals(str)) { + return i; + } + } + return -1; + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/sourcelookup/AdtSourceLookupDirector.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/sourcelookup/AdtSourceLookupDirector.java new file mode 100755 index 0000000..612ef76 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/sourcelookup/AdtSourceLookupDirector.java @@ -0,0 +1,97 @@ +/*
+ * Copyright (C) 2010 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.internal.sourcelookup;
+
+import com.android.ide.eclipse.adt.internal.project.AndroidClasspathContainerInitializer;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.debug.core.ILaunchConfiguration;
+import org.eclipse.debug.core.sourcelookup.ISourceContainer;
+import org.eclipse.debug.core.sourcelookup.containers.DefaultSourceContainer;
+import org.eclipse.debug.core.sourcelookup.containers.DirectorySourceContainer;
+import org.eclipse.debug.core.sourcelookup.containers.ExternalArchiveSourceContainer;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.internal.launching.JavaSourceLookupDirector;
+
+import java.io.File;
+
+public class AdtSourceLookupDirector extends JavaSourceLookupDirector {
+
+ @Override
+ public void initializeDefaults(ILaunchConfiguration configuration) throws CoreException {
+ dispose();
+ setLaunchConfiguration(configuration);
+ String projectName = configuration.getAttribute("org.eclipse.jdt.launching.PROJECT_ATTR", //$NON-NLS-1$
+ ""); //$NON-NLS-1$
+ if (projectName != null && projectName.length() > 0) {
+ IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
+ if (project != null && project.isOpen()) {
+ IJavaProject javaProject = JavaCore.create(project);
+ if (javaProject != null && javaProject.isOpen()) {
+ IClasspathEntry[] entries = javaProject.getRawClasspath();
+ IClasspathEntry androidEntry = null;
+ for (int i = 0; i < entries.length; i++) {
+ IClasspathEntry entry = entries[i];
+ if (entry.getPath() != null
+ && AndroidClasspathContainerInitializer.CONTAINER_ID.equals(entry
+ .getPath().toString())) {
+ androidEntry = entry;
+ break;
+ }
+ }
+ if (androidEntry != null) {
+ IPath sourceAttachmentPath = androidEntry.getSourceAttachmentPath();
+ if (sourceAttachmentPath != null) {
+ String androidSrc = sourceAttachmentPath.toString();
+ if (androidSrc != null && androidSrc.trim().length() > 0) {
+ File srcFile = new File(androidSrc);
+ ISourceContainer adtContainer = null;
+ if (srcFile.isFile()) {
+ adtContainer = new ExternalArchiveSourceContainer(androidSrc,
+ true);
+ }
+ if (srcFile.isDirectory()) {
+ adtContainer = new DirectorySourceContainer(srcFile, false);
+ }
+ if (adtContainer != null) {
+ ISourceContainer defaultContainer =
+ new DefaultSourceContainer();
+ setSourceContainers(new ISourceContainer[] {
+ adtContainer, defaultContainer
+ });
+ initializeParticipants();
+ return;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ setSourceContainers(new ISourceContainer[] {
+ new DefaultSourceContainer()
+ });
+ initializeParticipants();
+ }
+
+}
|