Java tutorial
/* * Copyright (C) 2011 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.editors.manifest; import static com.android.SdkConstants.ANDROID_STYLE_RESOURCE_PREFIX; import static com.android.SdkConstants.CLASS_ACTIVITY; import static com.android.SdkConstants.NS_RESOURCES; import static com.android.xml.AndroidManifest.ATTRIBUTE_ICON; import static com.android.xml.AndroidManifest.ATTRIBUTE_LABEL; import static com.android.xml.AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION; import static com.android.xml.AndroidManifest.ATTRIBUTE_NAME; import static com.android.xml.AndroidManifest.ATTRIBUTE_PACKAGE; import static com.android.xml.AndroidManifest.ATTRIBUTE_PARENT_ACTIVITY_NAME; import static com.android.xml.AndroidManifest.ATTRIBUTE_SUPPORTS_RTL; import static com.android.xml.AndroidManifest.ATTRIBUTE_TARGET_SDK_VERSION; import static com.android.xml.AndroidManifest.ATTRIBUTE_THEME; import static com.android.xml.AndroidManifest.ATTRIBUTE_UI_OPTIONS; import static com.android.xml.AndroidManifest.ATTRIBUTE_VALUE; import static com.android.xml.AndroidManifest.NODE_ACTIVITY; import static com.android.xml.AndroidManifest.NODE_METADATA; import static com.android.xml.AndroidManifest.NODE_USES_SDK; import static com.android.xml.AndroidManifest.VALUE_PARENT_ACTIVITY; import static org.eclipse.jdt.core.search.IJavaSearchConstants.REFERENCES; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.ide.eclipse.adt.io.IFolderWrapper; import com.android.io.IAbstractFile; import com.android.io.StreamException; import com.android.resources.ScreenSize; import com.android.sdklib.IAndroidTarget; import com.android.utils.Pair; import com.android.xml.AndroidManifest; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; 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.NullProgressMonitor; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.QualifiedName; import org.eclipse.jdt.core.IField; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.ITypeHierarchy; import org.eclipse.jdt.core.search.IJavaSearchScope; import org.eclipse.jdt.core.search.SearchEngine; import org.eclipse.jdt.core.search.SearchMatch; import org.eclipse.jdt.core.search.SearchParticipant; import org.eclipse.jdt.core.search.SearchPattern; import org.eclipse.jdt.core.search.SearchRequestor; import org.eclipse.jdt.internal.core.BinaryType; import org.eclipse.jface.text.IDocument; import org.eclipse.ui.editors.text.TextFileDocumentProvider; import org.eclipse.ui.texteditor.IDocumentProvider; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.xpath.XPathExpressionException; /** * Retrieves and caches manifest information such as the themes to be used for * a given activity. * * @see AndroidManifest */ public class ManifestInfo { public static class ActivityAttributes { @Nullable private final String mIcon; @Nullable private final String mLabel; @NonNull private final String mName; @Nullable private final String mParentActivity; @Nullable private final String mTheme; @Nullable private final String mUiOptions; public ActivityAttributes(Element activity, String packageName) { // Get activity name. String name = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_NAME); if (name == null || name.length() == 0) { throw new RuntimeException("Activity name cannot be empty"); } int index = name.indexOf('.'); if (index <= 0 && packageName != null && !packageName.isEmpty()) { name = packageName + (index == -1 ? "." : "") + name; } mName = name; // Get activity icon. String value = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_ICON); if (value != null && value.length() > 0) { mIcon = value; } else { mIcon = null; } // Get activity label. value = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_LABEL); if (value != null && value.length() > 0) { mLabel = value; } else { mLabel = null; } // Get activity parent. Also search the meta-data for parent info. value = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_PARENT_ACTIVITY_NAME); if (value == null || value.length() == 0) { // TODO: Not sure if meta data can be used for API Level > 16 NodeList metaData = activity.getElementsByTagName(NODE_METADATA); for (int j = 0, m = metaData.getLength(); j < m; j++) { Element data = (Element) metaData.item(j); String metadataName = data.getAttributeNS(NS_RESOURCES, ATTRIBUTE_NAME); if (VALUE_PARENT_ACTIVITY.equals(metadataName)) { value = data.getAttributeNS(NS_RESOURCES, ATTRIBUTE_VALUE); if (value != null) { index = value.indexOf('.'); if (index <= 0 && packageName != null && !packageName.isEmpty()) { value = packageName + (index == -1 ? "." : "") + value; break; } } } } } if (value != null && value.length() > 0) { mParentActivity = value; } else { mParentActivity = null; } // Get activity theme. value = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_THEME); if (value != null && value.length() > 0) { mTheme = value; } else { mTheme = null; } // Get UI options. value = activity.getAttributeNS(NS_RESOURCES, ATTRIBUTE_UI_OPTIONS); if (value != null && value.length() > 0) { mUiOptions = value; } else { mUiOptions = null; } } @Nullable public String getIcon() { return mIcon; } @Nullable public String getLabel() { return mLabel; } public String getName() { return mName; } @Nullable public String getParentActivity() { return mParentActivity; } @Nullable public String getTheme() { return mTheme; } @Nullable public String getUiOptions() { return mUiOptions; } } /** * The maximum number of milliseconds to search for an activity in the codebase when * attempting to associate layouts with activities in * {@link #guessActivity(IFile, String)} */ private static final int SEARCH_TIMEOUT_MS = 3000; private final IProject mProject; private String mPackage; private String mManifestTheme; private Map<String, ActivityAttributes> mActivityAttributes; private IAbstractFile mManifestFile; private long mLastModified; private long mLastChecked; private String mMinSdkName; private int mMinSdk; private int mTargetSdk; private String mApplicationIcon; private String mApplicationLabel; private boolean mApplicationSupportsRtl; /** * Qualified name for the per-project non-persistent property storing the * {@link ManifestInfo} for this project */ final static QualifiedName MANIFEST_FINDER = new QualifiedName(AdtPlugin.PLUGIN_ID, "manifest"); //$NON-NLS-1$ /** * Constructs an {@link ManifestInfo} for the given project. Don't use this method; * use the {@link #get} factory method instead. * * @param project project to create an {@link ManifestInfo} for */ private ManifestInfo(IProject project) { mProject = project; } /** * Clears the cached manifest information. The next get call on one of the * properties will cause the information to be refreshed. */ public void clear() { mLastChecked = 0; } /** * Returns the {@link ManifestInfo} for the given project * * @param project the project the finder is associated with * @return a {@ManifestInfo} for the given project, never null */ @NonNull public static ManifestInfo get(IProject project) { ManifestInfo finder = null; try { finder = (ManifestInfo) project.getSessionProperty(MANIFEST_FINDER); } catch (CoreException e) { // Not a problem; we will just create a new one } if (finder == null) { finder = new ManifestInfo(project); try { project.setSessionProperty(MANIFEST_FINDER, finder); } catch (CoreException e) { AdtPlugin.log(e, "Can't store ManifestInfo"); } } return finder; } /** * Ensure that the package, theme and activity maps are initialized and up to date * with respect to the manifest file */ private void sync() { // Since each of the accessors call sync(), allow a bunch of immediate // accessors to all bypass the file stat() below long now = System.currentTimeMillis(); if (now - mLastChecked < 50 && mManifestFile != null) { return; } mLastChecked = now; if (mManifestFile == null) { IFolderWrapper projectFolder = new IFolderWrapper(mProject); mManifestFile = AndroidManifest.getManifest(projectFolder); if (mManifestFile == null) { return; } } // Check to see if our data is up to date long fileModified = mManifestFile.getModificationStamp(); if (fileModified == mLastModified) { // Already have up to date data return; } mLastModified = fileModified; mActivityAttributes = new HashMap<String, ActivityAttributes>(); mManifestTheme = null; mTargetSdk = 1; // Default when not specified mMinSdk = 1; // Default when not specified mMinSdkName = "1"; // Default when not specified mPackage = ""; //$NON-NLS-1$ mApplicationIcon = null; mApplicationLabel = null; mApplicationSupportsRtl = false; Document document = null; try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); InputSource is = new InputSource(mManifestFile.getContents()); factory.setNamespaceAware(true); factory.setValidating(false); DocumentBuilder builder = factory.newDocumentBuilder(); document = builder.parse(is); Element root = document.getDocumentElement(); mPackage = root.getAttribute(ATTRIBUTE_PACKAGE); NodeList activities = document.getElementsByTagName(NODE_ACTIVITY); for (int i = 0, n = activities.getLength(); i < n; i++) { Element activity = (Element) activities.item(i); ActivityAttributes info = new ActivityAttributes(activity, mPackage); mActivityAttributes.put(info.getName(), info); } NodeList applications = root.getElementsByTagName(AndroidManifest.NODE_APPLICATION); if (applications.getLength() > 0) { assert applications.getLength() == 1; Element application = (Element) applications.item(0); if (application.hasAttributeNS(NS_RESOURCES, ATTRIBUTE_ICON)) { mApplicationIcon = application.getAttributeNS(NS_RESOURCES, ATTRIBUTE_ICON); } if (application.hasAttributeNS(NS_RESOURCES, ATTRIBUTE_LABEL)) { mApplicationLabel = application.getAttributeNS(NS_RESOURCES, ATTRIBUTE_LABEL); } if (SdkConstants.VALUE_TRUE .equals(application.getAttributeNS(NS_RESOURCES, ATTRIBUTE_SUPPORTS_RTL))) { mApplicationSupportsRtl = true; } String defaultTheme = application.getAttributeNS(NS_RESOURCES, ATTRIBUTE_THEME); if (defaultTheme != null && !defaultTheme.isEmpty()) { // From manifest theme documentation: // "If that attribute is also not set, the default system theme is used." mManifestTheme = defaultTheme; } } // Look up target SDK NodeList usesSdks = root.getElementsByTagName(NODE_USES_SDK); if (usesSdks.getLength() > 0) { Element usesSdk = (Element) usesSdks.item(0); mMinSdk = getApiVersion(usesSdk, ATTRIBUTE_MIN_SDK_VERSION, 1); mTargetSdk = getApiVersion(usesSdk, ATTRIBUTE_TARGET_SDK_VERSION, mMinSdk); } } catch (SAXException e) { AdtPlugin.log(e, "Malformed manifest"); } catch (Exception e) { AdtPlugin.log(e, "Could not read Manifest data"); } } private int getApiVersion(Element usesSdk, String attribute, int defaultApiLevel) { String valueString = null; if (usesSdk.hasAttributeNS(NS_RESOURCES, attribute)) { valueString = usesSdk.getAttributeNS(NS_RESOURCES, attribute); if (attribute.equals(ATTRIBUTE_MIN_SDK_VERSION)) { mMinSdkName = valueString; } } if (valueString != null) { int apiLevel = -1; try { apiLevel = Integer.valueOf(valueString); } catch (NumberFormatException e) { // Handle codename if (Sdk.getCurrent() != null) { IAndroidTarget target = Sdk.getCurrent().getTargetFromHashString("android-" + valueString); //$NON-NLS-1$ if (target != null) { // codename future API level is current api + 1 apiLevel = target.getVersion().getApiLevel() + 1; } } } return apiLevel; } return defaultApiLevel; } /** * Returns the default package registered in the Android manifest * * @return the default package registered in the manifest */ @NonNull public String getPackage() { sync(); return mPackage; } /** * Returns a map from activity full class names to the corresponding {@link ActivityAttributes}. * * @return a map from activity fqcn to ActivityAttributes */ @NonNull public Map<String, ActivityAttributes> getActivityAttributesMap() { sync(); return mActivityAttributes; } /** * Returns the attributes of an activity given its full class name. */ @Nullable public ActivityAttributes getActivityAttributes(String activity) { return getActivityAttributesMap().get(activity); } /** * Returns the manifest theme registered on the application, if any * * @return a manifest theme, or null if none was registered */ @Nullable public String getManifestTheme() { sync(); return mManifestTheme; } /** * Returns the default theme for this project, by looking at the manifest default * theme registration, target SDK, rendering target, etc. * * @param renderingTarget the rendering target use to render the theme, or null * @param screenSize the screen size to obtain a default theme for, or null if unknown * @return the theme to use for this project, never null */ @NonNull public String getDefaultTheme(IAndroidTarget renderingTarget, ScreenSize screenSize) { sync(); if (mManifestTheme != null) { return mManifestTheme; } int renderingTargetSdk = mTargetSdk; if (renderingTarget != null) { renderingTargetSdk = renderingTarget.getVersion().getApiLevel(); } int apiLevel = Math.min(mTargetSdk, renderingTargetSdk); // For now this theme works only on XLARGE screens. When it works for all sizes, // add that new apiLevel to this check. if (apiLevel >= 11 && screenSize == ScreenSize.XLARGE || apiLevel >= 14) { return ANDROID_STYLE_RESOURCE_PREFIX + "Theme.Holo"; //$NON-NLS-1$ } else { return ANDROID_STYLE_RESOURCE_PREFIX + "Theme"; //$NON-NLS-1$ } } /** * Returns the application icon, or null * * @return the application icon, or null */ @Nullable public String getApplicationIcon() { sync(); return mApplicationIcon; } /** * Returns the application label, or null * * @return the application label, or null */ @Nullable public String getApplicationLabel() { sync(); return mApplicationLabel; } /** * Returns true if the application has RTL support. * * @return true if the application has RTL support. */ public boolean isRtlSupported() { sync(); return mApplicationSupportsRtl; } /** * Returns the target SDK version * * @return the target SDK version */ public int getTargetSdkVersion() { sync(); return mTargetSdk; } /** * Returns the minimum SDK version * * @return the minimum SDK version */ public int getMinSdkVersion() { sync(); return mMinSdk; } /** * Returns the minimum SDK version name (which may not be a numeric string, e.g. * it could be a codename). It will never be null or empty; if no min sdk version * was specified in the manifest, the return value will be "1". Use * {@link #getMinSdkCodeName()} instead if you want to look up whether there is a code name. * * @return the minimum SDK version */ @NonNull public String getMinSdkName() { sync(); if (mMinSdkName == null || mMinSdkName.isEmpty()) { mMinSdkName = "1"; //$NON-NLS-1$ } return mMinSdkName; } /** * Returns the code name used for the minimum SDK version, if any. * * @return the minSdkVersion codename or null */ @Nullable public String getMinSdkCodeName() { String minSdkName = getMinSdkName(); if (!Character.isDigit(minSdkName.charAt(0))) { return minSdkName; } return null; } /** * Returns the {@link IPackageFragment} for the package registered in the manifest * * @return the {@link IPackageFragment} for the package registered in the manifest */ @Nullable public IPackageFragment getPackageFragment() { sync(); try { IJavaProject javaProject = BaseProjectHelper.getJavaProject(mProject); if (javaProject != null) { IPackageFragmentRoot root = ManifestInfo.getSourcePackageRoot(javaProject); if (root != null) { return root.getPackageFragment(mPackage); } } } catch (CoreException e) { AdtPlugin.log(e, null); } return null; } /** * Returns the activity associated with the given layout file. Makes an educated guess * by peeking at the usages of the R.layout.name field corresponding to the layout and * if it finds a usage. * * @param project the project containing the layout * @param layoutName the layout whose activity we want to look up * @param pkg the package containing activities * @return the activity name */ @Nullable public static String guessActivity(IProject project, String layoutName, String pkg) { List<String> activities = guessActivities(project, layoutName, pkg); if (activities.size() > 0) { return activities.get(0); } else { return null; } } /** * Returns the activities associated with the given layout file. Makes an educated guess * by peeking at the usages of the R.layout.name field corresponding to the layout and * if it finds a usage. * * @param project the project containing the layout * @param layoutName the layout whose activity we want to look up * @param pkg the package containing activities * @return the activity name */ @NonNull public static List<String> guessActivities(IProject project, String layoutName, String pkg) { final LinkedList<String> activities = new LinkedList<String>(); SearchRequestor requestor = new SearchRequestor() { @Override public void acceptSearchMatch(SearchMatch match) throws CoreException { Object element = match.getElement(); if (element instanceof IMethod) { IMethod method = (IMethod) element; IType declaringType = method.getDeclaringType(); String fqcn = declaringType.getFullyQualifiedName(); if ((declaringType.getSuperclassName() != null && declaringType.getSuperclassName().endsWith("Activity")) //$NON-NLS-1$ || method.getElementName().equals("onCreate")) { //$NON-NLS-1$ activities.addFirst(fqcn); } else { activities.addLast(fqcn); } } } }; try { IJavaProject javaProject = BaseProjectHelper.getJavaProject(project); if (javaProject == null) { return Collections.emptyList(); } // TODO - look around a bit more and see if we can figure out whether the // call if from within a setContentView call! // Search for which java classes call setContentView(R.layout.layoutname); String typeFqcn = "R.layout"; //$NON-NLS-1$ if (pkg != null) { typeFqcn = pkg + '.' + typeFqcn; } IType type = javaProject.findType(typeFqcn); if (type != null) { IField field = type.getField(layoutName); if (field.exists()) { SearchPattern pattern = SearchPattern.createPattern(field, REFERENCES); try { search(requestor, javaProject, pattern); } catch (OperationCanceledException canceled) { // pass } } } } catch (CoreException e) { AdtPlugin.log(e, null); } return activities; } /** * Returns all activities found in the given project (including those in libraries, * except for android.jar itself) * * @param project the project * @return a list of activity classes as fully qualified class names */ @SuppressWarnings("restriction") // BinaryType @NonNull public static List<String> getProjectActivities(IProject project) { final List<String> activities = new ArrayList<String>(); try { final IJavaProject javaProject = BaseProjectHelper.getJavaProject(project); if (javaProject != null) { IType[] activityTypes = new IType[0]; IType activityType = javaProject.findType(CLASS_ACTIVITY); if (activityType != null) { ITypeHierarchy hierarchy = activityType.newTypeHierarchy(javaProject, new NullProgressMonitor()); activityTypes = hierarchy.getAllSubtypes(activityType); for (IType type : activityTypes) { if (type instanceof BinaryType && (type.getClassFile() == null || type.getClassFile().getResource() == null)) { continue; } activities.add(type.getFullyQualifiedName()); } } } } catch (CoreException e) { AdtPlugin.log(e, null); } return activities; } /** * Returns the activity associated with the given layout file. * <p> * This is an alternative to {@link #guessActivity(IFile, String)}. Whereas * guessActivity simply looks for references to "R.layout.foo", this method searches * for all usages of Activity#setContentView(int), and for each match it looks up the * corresponding call text (such as "setContentView(R.layout.foo)"). From this it uses * a regexp to pull out "foo" from this, and stores the association that layout "foo" * is associated with the activity class that contained the setContentView call. * <p> * This has two potential advantages: * <ol> * <li>It can be faster. We do the reference search -once-, and we've built a map of * all the layout-to-activity mappings which we can then immediately look up other * layouts for, which is particularly useful at startup when we have to compute the * layout activity associations to populate the theme choosers. * <li>It can be more accurate. Just because an activity references an "R.layout.foo" * field doesn't mean it's setting it as a content view. * </ol> * However, this second advantage is also its chief problem. There are some common * code constructs which means that the associated layout is not explicitly referenced * in a direct setContentView call; on a couple of sample projects I tested I found * patterns like for example "setContentView(v)" where "v" had been computed earlier. * Therefore, for now we're going to stick with the more general approach of just * looking up each field when needed. We're keeping the code around, though statically * compiled out with the "if (false)" construct below in case we revisit this. * * @param layoutFile the layout whose activity we want to look up * @return the activity name */ @SuppressWarnings("all") @Nullable public String guessActivityBySetContentView(String layoutName) { if (false) { // These should be fields final Pattern LAYOUT_FIELD_PATTERN = Pattern.compile("R\\.layout\\.([a-z0-9_]+)"); //$NON-NLS-1$ Map<String, String> mUsages = null; sync(); if (mUsages == null) { final Map<String, String> usages = new HashMap<String, String>(); mUsages = usages; SearchRequestor requestor = new SearchRequestor() { @Override public void acceptSearchMatch(SearchMatch match) throws CoreException { Object element = match.getElement(); if (element instanceof IMethod) { IMethod method = (IMethod) element; IType declaringType = method.getDeclaringType(); String fqcn = declaringType.getFullyQualifiedName(); IDocumentProvider provider = new TextFileDocumentProvider(); IResource resource = match.getResource(); try { provider.connect(resource); IDocument document = provider.getDocument(resource); if (document != null) { String matchText = document.get(match.getOffset(), match.getLength()); Matcher matcher = LAYOUT_FIELD_PATTERN.matcher(matchText); if (matcher.find()) { usages.put(matcher.group(1), fqcn); } } } catch (Exception e) { AdtPlugin.log(e, "Can't find range information for %1$s", resource.getName()); } finally { provider.disconnect(resource); } } } }; try { IJavaProject javaProject = BaseProjectHelper.getJavaProject(mProject); if (javaProject == null) { return null; } // Search for which java classes call setContentView(R.layout.layoutname); String typeFqcn = "R.layout"; //$NON-NLS-1$ if (mPackage != null) { typeFqcn = mPackage + '.' + typeFqcn; } IType activityType = javaProject.findType(CLASS_ACTIVITY); if (activityType != null) { IMethod method = activityType.getMethod("setContentView", new String[] { "I" }); //$NON-NLS-1$ //$NON-NLS-2$ if (method.exists()) { SearchPattern pattern = SearchPattern.createPattern(method, REFERENCES); search(requestor, javaProject, pattern); } } } catch (CoreException e) { AdtPlugin.log(e, null); } } return mUsages.get(layoutName); } return null; } /** * Performs a search using the given pattern, scope and handler. The search will abort * if it takes longer than {@link #SEARCH_TIMEOUT_MS} milliseconds. */ private static void search(SearchRequestor requestor, IJavaProject javaProject, SearchPattern pattern) throws CoreException { // Find the package fragment specified in the manifest; the activities should // live there. IJavaSearchScope scope = createPackageScope(javaProject); SearchParticipant[] participants = new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }; SearchEngine engine = new SearchEngine(); final long searchStart = System.currentTimeMillis(); NullProgressMonitor monitor = new NullProgressMonitor() { private boolean mCancelled; @Override public void internalWorked(double work) { long searchEnd = System.currentTimeMillis(); if (searchEnd - searchStart > SEARCH_TIMEOUT_MS) { mCancelled = true; } } @Override public boolean isCanceled() { return mCancelled; } }; engine.search(pattern, participants, scope, requestor, monitor); } /** Creates a package search scope for the first package root in the given java project */ private static IJavaSearchScope createPackageScope(IJavaProject javaProject) { IPackageFragmentRoot packageRoot = getSourcePackageRoot(javaProject); IJavaSearchScope scope; if (packageRoot != null) { IJavaElement[] scopeElements = new IJavaElement[] { packageRoot }; scope = SearchEngine.createJavaSearchScope(scopeElements); } else { scope = SearchEngine.createWorkspaceScope(); } return scope; } /** * Returns the first package root for the given java project * * @param javaProject the project to search in * @return the first package root, or null */ @Nullable public static IPackageFragmentRoot getSourcePackageRoot(IJavaProject javaProject) { IPackageFragmentRoot packageRoot = null; List<IPath> sources = BaseProjectHelper.getSourceClasspaths(javaProject); IWorkspace workspace = ResourcesPlugin.getWorkspace(); for (IPath path : sources) { IResource firstSource = workspace.getRoot().findMember(path); if (firstSource != null) { packageRoot = javaProject.getPackageFragmentRoot(firstSource); if (packageRoot != null) { break; } } } return packageRoot; } /** * Computes the minimum SDK and target SDK versions for the project * * @param project the project to look up the versions for * @return a pair of (minimum SDK, target SDK) versions, never null */ @NonNull public static Pair<Integer, Integer> computeSdkVersions(IProject project) { int mMinSdkVersion = 1; int mTargetSdkVersion = 1; IAbstractFile manifestFile = AndroidManifest.getManifest(new IFolderWrapper(project)); if (manifestFile != null) { try { Object value = AndroidManifest.getMinSdkVersion(manifestFile); mMinSdkVersion = 1; // Default case if missing if (value instanceof Integer) { mMinSdkVersion = ((Integer) value).intValue(); } else if (value instanceof String) { // handle codename, only if we can resolve it. if (Sdk.getCurrent() != null) { IAndroidTarget target = Sdk.getCurrent().getTargetFromHashString("android-" + value); //$NON-NLS-1$ if (target != null) { // codename future API level is current api + 1 mMinSdkVersion = target.getVersion().getApiLevel() + 1; } } } value = AndroidManifest.getTargetSdkVersion(manifestFile); if (value == null) { mTargetSdkVersion = mMinSdkVersion; } else if (value instanceof String) { // handle codename, only if we can resolve it. if (Sdk.getCurrent() != null) { IAndroidTarget target = Sdk.getCurrent().getTargetFromHashString("android-" + value); //$NON-NLS-1$ if (target != null) { // codename future API level is current api + 1 mTargetSdkVersion = target.getVersion().getApiLevel() + 1; } } } } catch (XPathExpressionException e) { // do nothing we'll use 1 below. } catch (StreamException e) { // do nothing we'll use 1 below. } } return Pair.of(mMinSdkVersion, mTargetSdkVersion); } }