| /* |
| * 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; |
| |
| import static com.android.SdkConstants.TOOLS_PREFIX; |
| import static com.android.SdkConstants.TOOLS_URI; |
| import static org.eclipse.ui.IWorkbenchPage.MATCH_INPUT; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.sdklib.SdkVersionInfo; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper.IProjectFilter; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.resources.ResourceFolderType; |
| import com.android.resources.ResourceType; |
| import com.android.sdklib.AndroidVersion; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.repository.PkgProps; |
| import com.android.utils.XmlUtils; |
| import com.google.common.io.ByteStreams; |
| import com.google.common.io.Closeables; |
| |
| import org.eclipse.core.filebuffers.FileBuffers; |
| import org.eclipse.core.filebuffers.ITextFileBuffer; |
| import org.eclipse.core.filebuffers.ITextFileBufferManager; |
| import org.eclipse.core.filebuffers.LocationKind; |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IURIEditorInput; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.editors.text.TextFileDocumentProvider; |
| import org.eclipse.ui.part.FileEditorInput; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| import java.io.File; |
| import java.io.InputStream; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| |
| |
| /** Utility methods for ADT */ |
| @SuppressWarnings("restriction") // WST API |
| public class AdtUtils { |
| /** |
| * Creates a Java class name out of the given string, if possible. For |
| * example, "My Project" becomes "MyProject", "hello" becomes "Hello", |
| * "Java's" becomes "Java", and so on. |
| * |
| * @param string the string to be massaged into a Java class |
| * @return the string as a Java class, or null if a class name could not be |
| * extracted |
| */ |
| @Nullable |
| public static String extractClassName(@NonNull String string) { |
| StringBuilder sb = new StringBuilder(string.length()); |
| int n = string.length(); |
| |
| int i = 0; |
| for (; i < n; i++) { |
| char c = Character.toUpperCase(string.charAt(i)); |
| if (Character.isJavaIdentifierStart(c)) { |
| sb.append(c); |
| i++; |
| break; |
| } |
| } |
| if (sb.length() > 0) { |
| for (; i < n; i++) { |
| char c = string.charAt(i); |
| if (Character.isJavaIdentifierPart(c)) { |
| sb.append(c); |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Strips off the last file extension from the given filename, e.g. |
| * "foo.backup.diff" will be turned into "foo.backup". |
| * <p> |
| * Note that dot files (e.g. ".profile") will be left alone. |
| * |
| * @param filename the filename to be stripped |
| * @return the filename without the last file extension. |
| */ |
| public static String stripLastExtension(String filename) { |
| int dotIndex = filename.lastIndexOf('.'); |
| if (dotIndex > 0) { // > 0 instead of != -1: Treat dot files (e.g. .profile) differently |
| return filename.substring(0, dotIndex); |
| } else { |
| return filename; |
| } |
| } |
| |
| /** |
| * Strips off all extensions from the given filename, e.g. "foo.9.png" will |
| * be turned into "foo". |
| * <p> |
| * Note that dot files (e.g. ".profile") will be left alone. |
| * |
| * @param filename the filename to be stripped |
| * @return the filename without any file extensions |
| */ |
| public static String stripAllExtensions(String filename) { |
| int dotIndex = filename.indexOf('.'); |
| if (dotIndex > 0) { // > 0 instead of != -1: Treat dot files (e.g. .profile) differently |
| return filename.substring(0, dotIndex); |
| } else { |
| return filename; |
| } |
| } |
| |
| /** |
| * Strips the given suffix from the given string, provided that the string ends with |
| * the suffix. |
| * |
| * @param string the full string to strip from |
| * @param suffix the suffix to strip out |
| * @return the string without the suffix at the end |
| */ |
| public static String stripSuffix(@NonNull String string, @NonNull String suffix) { |
| if (string.endsWith(suffix)) { |
| return string.substring(0, string.length() - suffix.length()); |
| } |
| |
| return string; |
| } |
| |
| /** |
| * Capitalizes the string, i.e. transforms the initial [a-z] into [A-Z]. |
| * Returns the string unmodified if the first character is not [a-z]. |
| * |
| * @param str The string to capitalize. |
| * @return The capitalized string |
| */ |
| public static String capitalize(String str) { |
| if (str == null || str.length() < 1 || Character.isUpperCase(str.charAt(0))) { |
| return str; |
| } |
| |
| StringBuilder sb = new StringBuilder(); |
| sb.append(Character.toUpperCase(str.charAt(0))); |
| sb.append(str.substring(1)); |
| return sb.toString(); |
| } |
| |
| /** |
| * Converts a CamelCase word into an underlined_word |
| * |
| * @param string the CamelCase version of the word |
| * @return the underlined version of the word |
| */ |
| public static String camelCaseToUnderlines(String string) { |
| if (string.isEmpty()) { |
| return string; |
| } |
| |
| StringBuilder sb = new StringBuilder(2 * string.length()); |
| int n = string.length(); |
| boolean lastWasUpperCase = Character.isUpperCase(string.charAt(0)); |
| for (int i = 0; i < n; i++) { |
| char c = string.charAt(i); |
| boolean isUpperCase = Character.isUpperCase(c); |
| if (isUpperCase && !lastWasUpperCase) { |
| sb.append('_'); |
| } |
| lastWasUpperCase = isUpperCase; |
| c = Character.toLowerCase(c); |
| sb.append(c); |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * Converts an underlined_word into a CamelCase word |
| * |
| * @param string the underlined word to convert |
| * @return the CamelCase version of the word |
| */ |
| public static String underlinesToCamelCase(String string) { |
| StringBuilder sb = new StringBuilder(string.length()); |
| int n = string.length(); |
| |
| int i = 0; |
| boolean upcaseNext = true; |
| for (; i < n; i++) { |
| char c = string.charAt(i); |
| if (c == '_') { |
| upcaseNext = true; |
| } else { |
| if (upcaseNext) { |
| c = Character.toUpperCase(c); |
| } |
| upcaseNext = false; |
| sb.append(c); |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns the current editor (the currently visible and active editor), or null if |
| * not found |
| * |
| * @return the current editor, or null |
| */ |
| public static IEditorPart getActiveEditor() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage page = window.getActivePage(); |
| if (page != null) { |
| return page.getActiveEditor(); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the current active workbench, or null if not found |
| * |
| * @return the current window, or null |
| */ |
| @Nullable |
| public static IWorkbenchWindow getActiveWorkbenchWindow() { |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window == null) { |
| IWorkbenchWindow[] windows = workbench.getWorkbenchWindows(); |
| if (windows.length > 0) { |
| window = windows[0]; |
| } |
| } |
| |
| return window; |
| } |
| |
| /** |
| * Returns the current active workbench page, or null if not found |
| * |
| * @return the current page, or null |
| */ |
| @Nullable |
| public static IWorkbenchPage getActiveWorkbenchPage() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage page = window.getActivePage(); |
| if (page == null) { |
| IWorkbenchPage[] pages = window.getPages(); |
| if (pages.length > 0) { |
| page = pages[0]; |
| } |
| } |
| |
| return page; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the current active workbench part, or null if not found |
| * |
| * @return the current active workbench part, or null |
| */ |
| @Nullable |
| public static IWorkbenchPart getActivePart() { |
| IWorkbenchWindow window = getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage activePage = window.getActivePage(); |
| if (activePage != null) { |
| return activePage.getActivePart(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the current text editor (the currently visible and active editor), or null |
| * if not found. |
| * |
| * @return the current text editor, or null |
| */ |
| public static ITextEditor getActiveTextEditor() { |
| IEditorPart editor = getActiveEditor(); |
| if (editor != null) { |
| if (editor instanceof ITextEditor) { |
| return (ITextEditor) editor; |
| } else { |
| return (ITextEditor) editor.getAdapter(ITextEditor.class); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Looks through the open editors and returns the editors that have the |
| * given file as input. |
| * |
| * @param file the file to search for |
| * @param restore whether editors should be restored (if they have an open |
| * tab, but the editor hasn't been restored since the most recent |
| * IDE start yet |
| * @return a collection of editors |
| */ |
| @NonNull |
| public static Collection<IEditorPart> findEditorsFor(@NonNull IFile file, boolean restore) { |
| FileEditorInput input = new FileEditorInput(file); |
| List<IEditorPart> result = null; |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IWorkbenchWindow[] windows = workbench.getWorkbenchWindows(); |
| for (IWorkbenchWindow window : windows) { |
| IWorkbenchPage[] pages = window.getPages(); |
| for (IWorkbenchPage page : pages) { |
| IEditorReference[] editors = page.findEditors(input, null, MATCH_INPUT); |
| if (editors != null) { |
| for (IEditorReference reference : editors) { |
| IEditorPart editor = reference.getEditor(restore); |
| if (editor != null) { |
| if (result == null) { |
| result = new ArrayList<IEditorPart>(); |
| } |
| result.add(editor); |
| } |
| } |
| } |
| } |
| } |
| |
| if (result == null) { |
| return Collections.emptyList(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Attempts to convert the given {@link URL} into a {@link File}. |
| * |
| * @param url the {@link URL} to be converted |
| * @return the corresponding {@link File}, which may not exist |
| */ |
| @NonNull |
| public static File getFile(@NonNull URL url) { |
| try { |
| // First try URL.toURI(): this will work for URLs that contain %20 for spaces etc. |
| // Unfortunately, it *doesn't* work for "broken" URLs where the URL contains |
| // spaces, which is often the case. |
| return new File(url.toURI()); |
| } catch (URISyntaxException e) { |
| // ...so as a fallback, go to the old url.getPath() method, which handles space paths. |
| return new File(url.getPath()); |
| } |
| } |
| |
| /** |
| * Returns the file for the current editor, if any. |
| * |
| * @return the file for the current editor, or null if none |
| */ |
| public static IFile getActiveFile() { |
| IEditorPart editor = getActiveEditor(); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| IFileEditorInput fileInput = (IFileEditorInput) input; |
| return fileInput.getFile(); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns an absolute path to the given resource |
| * |
| * @param resource the resource to look up a path for |
| * @return an absolute file system path to the resource |
| */ |
| @NonNull |
| public static IPath getAbsolutePath(@NonNull IResource resource) { |
| IPath location = resource.getRawLocation(); |
| if (location != null) { |
| return location.makeAbsolute(); |
| } else { |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IWorkspaceRoot root = workspace.getRoot(); |
| IPath workspacePath = root.getLocation(); |
| return workspacePath.append(resource.getFullPath()); |
| } |
| } |
| |
| /** |
| * Converts a workspace-relative path to an absolute file path |
| * |
| * @param path the workspace-relative path to convert |
| * @return the corresponding absolute file in the file system |
| */ |
| @NonNull |
| public static File workspacePathToFile(@NonNull IPath path) { |
| IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); |
| IResource res = root.findMember(path); |
| if (res != null) { |
| IPath location = res.getLocation(); |
| if (location != null) { |
| return location.toFile(); |
| } |
| return root.getLocation().append(path).toFile(); |
| } |
| |
| return path.toFile(); |
| } |
| |
| /** |
| * Converts a {@link File} to an {@link IFile}, if possible. |
| * |
| * @param file a file to be converted |
| * @return the corresponding {@link IFile}, or null |
| */ |
| public static IFile fileToIFile(File file) { |
| if (!file.isAbsolute()) { |
| file = file.getAbsoluteFile(); |
| } |
| |
| IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); |
| IFile[] files = workspace.findFilesForLocationURI(file.toURI()); |
| if (files.length > 0) { |
| return files[0]; |
| } |
| |
| IPath filePath = new Path(file.getPath()); |
| return pathToIFile(filePath); |
| } |
| |
| /** |
| * Converts a {@link File} to an {@link IResource}, if possible. |
| * |
| * @param file a file to be converted |
| * @return the corresponding {@link IResource}, or null |
| */ |
| public static IResource fileToResource(File file) { |
| if (!file.isAbsolute()) { |
| file = file.getAbsoluteFile(); |
| } |
| |
| IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); |
| IFile[] files = workspace.findFilesForLocationURI(file.toURI()); |
| if (files.length > 0) { |
| return files[0]; |
| } |
| |
| IPath filePath = new Path(file.getPath()); |
| return pathToResource(filePath); |
| } |
| |
| /** |
| * Converts a {@link IPath} to an {@link IFile}, if possible. |
| * |
| * @param path a path to be converted |
| * @return the corresponding {@link IFile}, or null |
| */ |
| public static IFile pathToIFile(IPath path) { |
| IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); |
| |
| IFile[] files = workspace.findFilesForLocationURI(URIUtil.toURI(path.makeAbsolute())); |
| if (files.length > 0) { |
| return files[0]; |
| } |
| |
| IPath workspacePath = workspace.getLocation(); |
| if (workspacePath.isPrefixOf(path)) { |
| IPath relativePath = path.makeRelativeTo(workspacePath); |
| IResource member = workspace.findMember(relativePath); |
| if (member instanceof IFile) { |
| return (IFile) member; |
| } |
| } else if (path.isAbsolute()) { |
| return workspace.getFileForLocation(path); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Converts a {@link IPath} to an {@link IResource}, if possible. |
| * |
| * @param path a path to be converted |
| * @return the corresponding {@link IResource}, or null |
| */ |
| public static IResource pathToResource(IPath path) { |
| IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); |
| |
| IFile[] files = workspace.findFilesForLocationURI(URIUtil.toURI(path.makeAbsolute())); |
| if (files.length > 0) { |
| return files[0]; |
| } |
| |
| IPath workspacePath = workspace.getLocation(); |
| if (workspacePath.isPrefixOf(path)) { |
| IPath relativePath = path.makeRelativeTo(workspacePath); |
| return workspace.findMember(relativePath); |
| } else if (path.isAbsolute()) { |
| return workspace.getFileForLocation(path); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns all markers in a file/document that fit on the same line as the given offset |
| * |
| * @param markerType the marker type |
| * @param file the file containing the markers |
| * @param document the document showing the markers |
| * @param offset the offset to be checked |
| * @return a list (possibly empty but never null) of matching markers |
| */ |
| @NonNull |
| public static List<IMarker> findMarkersOnLine( |
| @NonNull String markerType, |
| @NonNull IResource file, |
| @NonNull IDocument document, |
| int offset) { |
| List<IMarker> matchingMarkers = new ArrayList<IMarker>(2); |
| try { |
| IMarker[] markers = file.findMarkers(markerType, true, IResource.DEPTH_ZERO); |
| |
| // Look for a match on the same line as the caret. |
| IRegion lineInfo = document.getLineInformationOfOffset(offset); |
| int lineStart = lineInfo.getOffset(); |
| int lineEnd = lineStart + lineInfo.getLength(); |
| int offsetLine = document.getLineOfOffset(offset); |
| |
| |
| for (IMarker marker : markers) { |
| int start = marker.getAttribute(IMarker.CHAR_START, -1); |
| int end = marker.getAttribute(IMarker.CHAR_END, -1); |
| if (start >= lineStart && start <= lineEnd && end > start) { |
| matchingMarkers.add(marker); |
| } else if (start == -1 && end == -1) { |
| // Some markers don't set character range, they only set the line |
| int line = marker.getAttribute(IMarker.LINE_NUMBER, -1); |
| if (line == offsetLine + 1) { |
| matchingMarkers.add(marker); |
| } |
| } |
| } |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } catch (BadLocationException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| return matchingMarkers; |
| } |
| |
| /** |
| * Returns the available and open Android projects |
| * |
| * @return the available and open Android projects, never null |
| */ |
| @NonNull |
| public static IJavaProject[] getOpenAndroidProjects() { |
| return BaseProjectHelper.getAndroidProjects(new IProjectFilter() { |
| @Override |
| public boolean accept(IProject project) { |
| return project.isAccessible(); |
| } |
| }); |
| } |
| |
| /** |
| * Returns a unique project name, based on the given {@code base} file name |
| * possibly with a {@code conjunction} and a new number behind it to ensure |
| * that the project name is unique. For example, |
| * {@code getUniqueProjectName("project", "_")} will return |
| * {@code "project"} if that name does not already exist, and if it does, it |
| * will return {@code "project_2"}. |
| * |
| * @param base the base name to use, such as "foo" |
| * @param conjunction a string to insert between the base name and the |
| * number. |
| * @return a unique project name based on the given base and conjunction |
| */ |
| public static String getUniqueProjectName(String base, String conjunction) { |
| // We're using all workspace projects here rather than just open Android project |
| // via getOpenAndroidProjects because the name cannot conflict with non-Android |
| // or closed projects either |
| IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); |
| IProject[] projects = workspaceRoot.getProjects(); |
| |
| for (int i = 1; i < 1000; i++) { |
| String name = i == 1 ? base : base + conjunction + Integer.toString(i); |
| boolean found = false; |
| for (IProject project : projects) { |
| // Need to make case insensitive comparison, since otherwise we can hit |
| // org.eclipse.core.internal.resources.ResourceException: |
| // A resource exists with a different case: '/test'. |
| if (project.getName().equalsIgnoreCase(name)) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| return name; |
| } |
| } |
| |
| return base; |
| } |
| |
| /** |
| * Returns the name of the parent folder for the given editor input |
| * |
| * @param editorInput the editor input to check |
| * @return the parent folder, which is never null but may be "" |
| */ |
| @NonNull |
| public static String getParentFolderName(@Nullable IEditorInput editorInput) { |
| if (editorInput instanceof IFileEditorInput) { |
| IFile file = ((IFileEditorInput) editorInput).getFile(); |
| return file.getParent().getName(); |
| } |
| |
| if (editorInput instanceof IURIEditorInput) { |
| IURIEditorInput urlEditorInput = (IURIEditorInput) editorInput; |
| String path = urlEditorInput.getURI().toString(); |
| int lastIndex = path.lastIndexOf('/'); |
| if (lastIndex != -1) { |
| int lastLastIndex = path.lastIndexOf('/', lastIndex - 1); |
| if (lastLastIndex != -1) { |
| return path.substring(lastLastIndex + 1, lastIndex); |
| } |
| } |
| } |
| |
| return ""; |
| } |
| |
| /** |
| * Returns the XML editor for the given editor part |
| * |
| * @param part the editor part to look up the editor for |
| * @return the editor or null if this part is not an XML editor |
| */ |
| @Nullable |
| public static AndroidXmlEditor getXmlEditor(@NonNull IEditorPart part) { |
| if (part instanceof AndroidXmlEditor) { |
| return (AndroidXmlEditor) part; |
| } else if (part instanceof GraphicalEditorPart) { |
| ((GraphicalEditorPart) part).getEditorDelegate().getEditor(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Sets the given tools: attribute in the given XML editor document, adding |
| * the tools name space declaration if necessary, formatting the affected |
| * document region, and optionally comma-appending to an existing value and |
| * optionally opening and revealing the attribute. |
| * |
| * @param editor the associated editor |
| * @param element the associated element |
| * @param description the description of the attribute (shown in the undo |
| * event) |
| * @param name the name of the attribute |
| * @param value the attribute value |
| * @param reveal if true, open the editor and select the given attribute |
| * node |
| * @param appendValue if true, add this value as a comma separated value to |
| * the existing attribute value, if any |
| */ |
| public static void setToolsAttribute( |
| @NonNull final AndroidXmlEditor editor, |
| @NonNull final Element element, |
| @NonNull final String description, |
| @NonNull final String name, |
| @Nullable final String value, |
| final boolean reveal, |
| final boolean appendValue) { |
| editor.wrapUndoEditXmlModel(description, new Runnable() { |
| @Override |
| public void run() { |
| String prefix = XmlUtils.lookupNamespacePrefix(element, TOOLS_URI, null, true); |
| if (prefix == null) { |
| // Add in new prefix... |
| prefix = XmlUtils.lookupNamespacePrefix(element, |
| TOOLS_URI, TOOLS_PREFIX, true /*create*/); |
| if (value != null) { |
| // ...and ensure that the header is formatted such that |
| // the XML namespace declaration is placed in the right |
| // position and wrapping is applied etc. |
| editor.scheduleNodeReformat(editor.getUiRootNode(), |
| true /*attributesOnly*/); |
| } |
| } |
| |
| String v = value; |
| if (appendValue && v != null) { |
| String prev = element.getAttributeNS(TOOLS_URI, name); |
| if (prev.length() > 0) { |
| v = prev + ',' + value; |
| } |
| } |
| |
| // Use the non-namespace form of set attribute since we can't |
| // reference the namespace until the model has been reloaded |
| if (v != null) { |
| element.setAttribute(prefix + ':' + name, v); |
| } else { |
| element.removeAttribute(prefix + ':' + name); |
| } |
| |
| UiElementNode rootUiNode = editor.getUiRootNode(); |
| if (rootUiNode != null && v != null) { |
| final UiElementNode uiNode = rootUiNode.findXmlNode(element); |
| if (uiNode != null) { |
| editor.scheduleNodeReformat(uiNode, true /*attributesOnly*/); |
| |
| if (reveal) { |
| // Update editor selection after format |
| Display display = AdtPlugin.getDisplay(); |
| if (display != null) { |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| Node xmlNode = uiNode.getXmlNode(); |
| Attr attribute = ((Element) xmlNode).getAttributeNodeNS( |
| TOOLS_URI, name); |
| if (attribute instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion) attribute; |
| editor.getStructuredTextEditor().selectAndReveal( |
| region.getStartOffset(), region.getLength()); |
| } |
| } |
| }); |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Returns a string label for the given target, of the form |
| * "API 16: Android 4.1 (Jelly Bean)". |
| * |
| * @param target the target to generate a string from |
| * @return a suitable display string |
| */ |
| @NonNull |
| public static String getTargetLabel(@NonNull IAndroidTarget target) { |
| if (target.isPlatform()) { |
| AndroidVersion version = target.getVersion(); |
| String codename = target.getProperty(PkgProps.PLATFORM_CODENAME); |
| String release = target.getProperty("ro.build.version.release"); //$NON-NLS-1$ |
| if (codename != null) { |
| return String.format("API %1$d: Android %2$s (%3$s)", |
| version.getApiLevel(), |
| release, |
| codename); |
| } |
| return String.format("API %1$d: Android %2$s", version.getApiLevel(), |
| release); |
| } |
| |
| return String.format("%1$s (API %2$s)", target.getFullName(), |
| target.getVersion().getApiString()); |
| } |
| |
| /** |
| * Sets the given tools: attribute in the given XML editor document, adding |
| * the tools name space declaration if necessary, and optionally |
| * comma-appending to an existing value. |
| * |
| * @param file the file associated with the element |
| * @param element the associated element |
| * @param description the description of the attribute (shown in the undo |
| * event) |
| * @param name the name of the attribute |
| * @param value the attribute value |
| * @param appendValue if true, add this value as a comma separated value to |
| * the existing attribute value, if any |
| */ |
| public static void setToolsAttribute( |
| @NonNull final IFile file, |
| @NonNull final Element element, |
| @NonNull final String description, |
| @NonNull final String name, |
| @Nullable final String value, |
| final boolean appendValue) { |
| IModelManager modelManager = StructuredModelManager.getModelManager(); |
| if (modelManager == null) { |
| return; |
| } |
| |
| try { |
| IStructuredModel model = null; |
| if (model == null) { |
| model = modelManager.getModelForEdit(file); |
| } |
| if (model != null) { |
| try { |
| model.aboutToChangeModel(); |
| if (model instanceof IDOMModel) { |
| IDOMModel domModel = (IDOMModel) model; |
| Document doc = domModel.getDocument(); |
| if (doc != null && element.getOwnerDocument() == doc) { |
| String prefix = XmlUtils.lookupNamespacePrefix(element, TOOLS_URI, |
| null, true); |
| if (prefix == null) { |
| // Add in new prefix... |
| prefix = XmlUtils.lookupNamespacePrefix(element, |
| TOOLS_URI, TOOLS_PREFIX, true); |
| } |
| |
| String v = value; |
| if (appendValue && v != null) { |
| String prev = element.getAttributeNS(TOOLS_URI, name); |
| if (prev.length() > 0) { |
| v = prev + ',' + value; |
| } |
| } |
| |
| // Use the non-namespace form of set attribute since we can't |
| // reference the namespace until the model has been reloaded |
| if (v != null) { |
| element.setAttribute(prefix + ':' + name, v); |
| } else { |
| element.removeAttribute(prefix + ':' + name); |
| } |
| } |
| } |
| } finally { |
| model.changedModel(); |
| String updated = model.getStructuredDocument().get(); |
| model.releaseFromEdit(); |
| model.save(file); |
| |
| // Must also force a save on disk since the above model.save(file) often |
| // (always?) has no effect. |
| ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager(); |
| NullProgressMonitor monitor = new NullProgressMonitor(); |
| IPath path = file.getFullPath(); |
| manager.connect(path, LocationKind.IFILE, monitor); |
| try { |
| ITextFileBuffer buffer = manager.getTextFileBuffer(path, |
| LocationKind.IFILE); |
| IDocument currentDocument = buffer.getDocument(); |
| currentDocument.set(updated); |
| buffer.commit(monitor, true); |
| } finally { |
| manager.disconnect(path, LocationKind.IFILE, monitor); |
| } |
| } |
| } |
| } catch (Exception e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| |
| /** |
| * Returns the Android version and code name of the given API level |
| * |
| * @param api the api level |
| * @return a suitable version display name |
| */ |
| public static String getAndroidName(int api) { |
| if (api <= SdkVersionInfo.HIGHEST_KNOWN_API) { |
| return SdkVersionInfo.getAndroidName(api); |
| } |
| |
| // Consult SDK manager to see if we know any more (later) names, |
| // installed by user |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk != null) { |
| for (IAndroidTarget target : sdk.getTargets()) { |
| if (target.isPlatform()) { |
| AndroidVersion version = target.getVersion(); |
| if (version.getApiLevel() == api) { |
| return getTargetLabel(target); |
| } |
| } |
| } |
| } |
| |
| return "API " + api; |
| } |
| |
| /** |
| * Returns the highest known API level to this version of ADT. The |
| * {@link #getAndroidName(int)} method will return real names up to and |
| * including this number. |
| * |
| * @return the highest known API number |
| */ |
| public static int getHighestKnownApiLevel() { |
| return SdkVersionInfo.HIGHEST_KNOWN_API; |
| } |
| |
| /** |
| * Returns a list of known API names |
| * |
| * @return a list of string API names, starting from 1 and up through the |
| * maximum known versions (with no gaps) |
| */ |
| public static String[] getKnownVersions() { |
| int max = getHighestKnownApiLevel(); |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk != null) { |
| for (IAndroidTarget target : sdk.getTargets()) { |
| if (target.isPlatform()) { |
| AndroidVersion version = target.getVersion(); |
| if (!version.isPreview()) { |
| max = Math.max(max, version.getApiLevel()); |
| } |
| } |
| } |
| } |
| |
| String[] versions = new String[max]; |
| for (int api = 1; api <= max; api++) { |
| versions[api-1] = getAndroidName(api); |
| } |
| |
| return versions; |
| } |
| |
| /** |
| * Returns the Android project(s) that are selected or active, if any. This |
| * considers the selection, the active editor, etc. |
| * |
| * @param selection the current selection |
| * @return a list of projects, possibly empty (but never null) |
| */ |
| @NonNull |
| public static List<IProject> getSelectedProjects(@Nullable ISelection selection) { |
| List<IProject> projects = new ArrayList<IProject>(); |
| |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection = (IStructuredSelection) selection; |
| // get the unique selected item. |
| Iterator<?> iterator = structuredSelection.iterator(); |
| while (iterator.hasNext()) { |
| Object element = iterator.next(); |
| |
| // First look up the resource (since some adaptables |
| // provide an IResource but not an IProject, and we can |
| // always go from IResource to IProject) |
| IResource resource = null; |
| if (element instanceof IResource) { // may include IProject |
| resource = (IResource) element; |
| } else if (element instanceof IAdaptable) { |
| IAdaptable adaptable = (IAdaptable)element; |
| Object adapter = adaptable.getAdapter(IResource.class); |
| resource = (IResource) adapter; |
| } |
| |
| // get the project object from it. |
| IProject project = null; |
| if (resource != null) { |
| project = resource.getProject(); |
| } else if (element instanceof IAdaptable) { |
| project = (IProject) ((IAdaptable) element).getAdapter(IProject.class); |
| } |
| |
| if (project != null && !projects.contains(project)) { |
| projects.add(project); |
| } |
| } |
| } |
| |
| if (projects.isEmpty()) { |
| // Try to look at the active editor instead |
| IFile file = AdtUtils.getActiveFile(); |
| if (file != null) { |
| projects.add(file.getProject()); |
| } |
| } |
| |
| if (projects.isEmpty()) { |
| // If we didn't find a default project based on the selection, check how many |
| // open Android projects we can find in the current workspace. If there's only |
| // one, we'll just select it by default. |
| IJavaProject[] open = AdtUtils.getOpenAndroidProjects(); |
| for (IJavaProject project : open) { |
| projects.add(project.getProject()); |
| } |
| return projects; |
| } else { |
| // Make sure all the projects are Android projects |
| List<IProject> androidProjects = new ArrayList<IProject>(projects.size()); |
| for (IProject project : projects) { |
| if (BaseProjectHelper.isAndroidProject(project)) { |
| androidProjects.add(project); |
| } |
| } |
| return androidProjects; |
| } |
| } |
| |
| private static Boolean sEclipse4; |
| |
| /** |
| * Returns true if the running Eclipse is version 4.x or later |
| * |
| * @return true if the current Eclipse version is 4.x or later, false |
| * otherwise |
| */ |
| public static boolean isEclipse4() { |
| if (sEclipse4 == null) { |
| sEclipse4 = Platform.getBundle("org.eclipse.e4.ui.model.workbench") != null; //$NON-NLS-1$ |
| } |
| |
| return sEclipse4; |
| } |
| |
| /** |
| * Reads the contents of an {@link IFile} and return it as a byte array |
| * |
| * @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 byte[] readData(@NonNull IFile file) { |
| InputStream contents = null; |
| try { |
| contents = file.getContents(); |
| return ByteStreams.toByteArray(contents); |
| } catch (Exception e) { |
| // Pass -- just return null |
| } finally { |
| Closeables.closeQuietly(contents); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Ensure that a given folder (and all its parents) are created. This implements |
| * the equivalent of {@link File#mkdirs()} for {@link IContainer} folders. |
| * |
| * @param container the container to ensure exists |
| * @throws CoreException if an error occurs |
| */ |
| public static void ensureExists(@Nullable IContainer container) throws CoreException { |
| if (container == null || container.exists()) { |
| return; |
| } |
| IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); |
| IFolder folder = root.getFolder(container.getFullPath()); |
| ensureExists(folder); |
| } |
| |
| private static void ensureExists(IFolder folder) throws CoreException { |
| if (folder != null && !folder.exists()) { |
| IContainer parent = folder.getParent(); |
| if (parent instanceof IFolder) { |
| ensureExists((IFolder) parent); |
| } |
| folder.create(false, false, null); |
| } |
| } |
| |
| /** |
| * Format the given floating value into an XML string, omitting decimals if |
| * 0 |
| * |
| * @param value the value to be formatted |
| * @return the corresponding XML string for the value |
| */ |
| public static String formatFloatAttribute(float value) { |
| if (value != (int) value) { |
| // Run String.format without a locale, because we don't want locale-specific |
| // conversions here like separating the decimal part with a comma instead of a dot! |
| return String.format((Locale) null, "%.2f", value); //$NON-NLS-1$ |
| } else { |
| return Integer.toString((int) value); |
| } |
| } |
| |
| /** |
| * Creates all the directories required for the given path. |
| * |
| * @param wsPath the path to create all the parent directories for |
| * @return true if all the parent directories were created |
| */ |
| public static boolean createWsParentDirectory(IContainer wsPath) { |
| if (wsPath.getType() == IResource.FOLDER) { |
| if (wsPath.exists()) { |
| return true; |
| } |
| |
| IFolder folder = (IFolder) wsPath; |
| try { |
| if (createWsParentDirectory(wsPath.getParent())) { |
| folder.create(true /* force */, true /* local */, null /* monitor */); |
| return true; |
| } |
| } catch (CoreException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Lists the files of the given directory and returns them as an array which |
| * is never null. This simplifies processing file listings from for each |
| * loops since {@link File#listFiles} can return null. This method simply |
| * wraps it and makes sure it returns an empty array instead if necessary. |
| * |
| * @param dir the directory to list |
| * @return the children, or empty if it has no children, is not a directory, |
| * etc. |
| */ |
| @NonNull |
| public static File[] listFiles(File dir) { |
| File[] files = dir.listFiles(); |
| if (files != null) { |
| return files; |
| } else { |
| return new File[0]; |
| } |
| } |
| |
| /** |
| * Closes all open editors that are showing a file for the given project. This method |
| * should be called when a project is closed or deleted. |
| * <p> |
| * This method can be called from any thread, but if it is not called on the GUI thread |
| * the editor will be closed asynchronously. |
| * |
| * @param project the project to close all editors for |
| * @param save whether unsaved editors should be saved first |
| */ |
| public static void closeEditors(@NonNull final IProject project, final boolean save) { |
| final Display display = AdtPlugin.getDisplay(); |
| if (display == null || display.isDisposed()) { |
| return; |
| } |
| if (display.getThread() != Thread.currentThread()) { |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| closeEditors(project, save); |
| } |
| }); |
| return; |
| } |
| |
| // Close editors for removed files |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| for (IWorkbenchWindow window : workbench.getWorkbenchWindows()) { |
| for (IWorkbenchPage page : window.getPages()) { |
| List<IEditorReference> matching = null; |
| for (IEditorReference ref : page.getEditorReferences()) { |
| boolean close = false; |
| try { |
| IEditorInput input = ref.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| IFileEditorInput fileInput = (IFileEditorInput) input; |
| if (project.equals(fileInput.getFile().getProject())) { |
| close = true; |
| } |
| } |
| } catch (PartInitException ex) { |
| close = true; |
| } |
| if (close) { |
| if (matching == null) { |
| matching = new ArrayList<IEditorReference>(2); |
| } |
| matching.add(ref); |
| } |
| } |
| if (matching != null) { |
| IEditorReference[] refs = new IEditorReference[matching.size()]; |
| page.closeEditors(matching.toArray(refs), save); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Closes all open editors for the given file. Note that a file can be open in |
| * more than one editor, for example by using Open With on the file to choose different |
| * editors. |
| * <p> |
| * This method can be called from any thread, but if it is not called on the GUI thread |
| * the editor will be closed asynchronously. |
| * |
| * @param file the file whose editors should be closed. |
| * @param save whether unsaved editors should be saved first |
| */ |
| public static void closeEditors(@NonNull final IFile file, final boolean save) { |
| final Display display = AdtPlugin.getDisplay(); |
| if (display == null || display.isDisposed()) { |
| return; |
| } |
| if (display.getThread() != Thread.currentThread()) { |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| closeEditors(file, save); |
| } |
| }); |
| return; |
| } |
| |
| // Close editors for removed files |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| for (IWorkbenchWindow window : workbench.getWorkbenchWindows()) { |
| for (IWorkbenchPage page : window.getPages()) { |
| List<IEditorReference> matching = null; |
| for (IEditorReference ref : page.getEditorReferences()) { |
| boolean close = false; |
| try { |
| IEditorInput input = ref.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| IFileEditorInput fileInput = (IFileEditorInput) input; |
| if (file.equals(fileInput.getFile())) { |
| close = true; |
| } |
| } |
| } catch (PartInitException ex) { |
| close = true; |
| } |
| if (close) { |
| // Found |
| if (matching == null) { |
| matching = new ArrayList<IEditorReference>(2); |
| } |
| matching.add(ref); |
| // We don't break here in case the file is |
| // opened multiple times with different editors. |
| } |
| } |
| if (matching != null) { |
| IEditorReference[] refs = new IEditorReference[matching.size()]; |
| page.closeEditors(matching.toArray(refs), save); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the offset region of the given 0-based line number in the given |
| * file |
| * |
| * @param file the file to look up the line number in |
| * @param line the line number (0-based, meaning that the first line is line |
| * 0) |
| * @return the corresponding offset range, or null |
| */ |
| @Nullable |
| public static IRegion getRegionOfLine(@NonNull IFile file, int line) { |
| IDocumentProvider provider = new TextFileDocumentProvider(); |
| try { |
| provider.connect(file); |
| IDocument document = provider.getDocument(file); |
| if (document != null) { |
| return document.getLineInformation(line); |
| } |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Can't find range information for %1$s", file.getName()); |
| } finally { |
| provider.disconnect(file); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns all resource variations for the given file |
| * |
| * @param file resource file, which should be an XML file in one of the |
| * various resource folders, e.g. res/layout, res/values-xlarge, etc. |
| * @param includeSelf if true, include the file itself in the list, |
| * otherwise exclude it |
| * @return a list of all the resource variations |
| */ |
| public static List<IFile> getResourceVariations(@Nullable IFile file, boolean includeSelf) { |
| if (file == null) { |
| return Collections.emptyList(); |
| } |
| |
| // Compute the set of layout files defining this layout resource |
| List<IFile> variations = new ArrayList<IFile>(); |
| String name = file.getName(); |
| IContainer parent = file.getParent(); |
| if (parent != null) { |
| IContainer resFolder = parent.getParent(); |
| if (resFolder != null) { |
| String parentName = parent.getName(); |
| String prefix = parentName; |
| int qualifiers = prefix.indexOf('-'); |
| |
| if (qualifiers != -1) { |
| parentName = prefix.substring(0, qualifiers); |
| prefix = prefix.substring(0, qualifiers + 1); |
| } else { |
| prefix = prefix + '-'; |
| } |
| try { |
| for (IResource resource : resFolder.members()) { |
| String n = resource.getName(); |
| if ((n.startsWith(prefix) || n.equals(parentName)) |
| && resource instanceof IContainer) { |
| IContainer layoutFolder = (IContainer) resource; |
| IResource r = layoutFolder.findMember(name); |
| if (r instanceof IFile) { |
| IFile variation = (IFile) r; |
| if (!includeSelf && file.equals(variation)) { |
| continue; |
| } |
| variations.add(variation); |
| } |
| } |
| } |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| } |
| |
| return variations; |
| } |
| |
| /** |
| * Returns whether the current thread is the UI thread |
| * |
| * @return true if the current thread is the UI thread |
| */ |
| public static boolean isUiThread() { |
| return AdtPlugin.getDisplay() != null |
| && AdtPlugin.getDisplay().getThread() == Thread.currentThread(); |
| } |
| |
| /** |
| * Replaces any {@code \\uNNNN} references in the given string with the corresponding |
| * unicode characters. |
| * |
| * @param s the string to perform replacements in |
| * @return the string with unicode escapes replaced with actual characters |
| */ |
| @NonNull |
| public static String replaceUnicodeEscapes(@NonNull String s) { |
| // Handle unicode escapes |
| if (s.indexOf("\\u") != -1) { //$NON-NLS-1$ |
| StringBuilder sb = new StringBuilder(s.length()); |
| for (int i = 0, n = s.length(); i < n; i++) { |
| char c = s.charAt(i); |
| if (c == '\\' && i < n - 1) { |
| char next = s.charAt(i + 1); |
| if (next == 'u' && i < n - 5) { // case sensitive |
| String hex = s.substring(i + 2, i + 6); |
| try { |
| int unicodeValue = Integer.parseInt(hex, 16); |
| sb.append((char) unicodeValue); |
| i += 5; |
| continue; |
| } catch (NumberFormatException nufe) { |
| // Invalid escape: Just proceed to literally transcribe it |
| sb.append(c); |
| } |
| } else { |
| sb.append(c); |
| sb.append(next); |
| i++; |
| continue; |
| } |
| } else { |
| sb.append(c); |
| } |
| } |
| s = sb.toString(); |
| } |
| |
| return s; |
| } |
| |
| /** |
| * Looks up the {@link ResourceFolderType} corresponding to a given |
| * {@link ResourceType}: the folder where those resources can be found. |
| * <p> |
| * Note that {@link ResourceType#ID} is a special case: it can not just |
| * be defined in {@link ResourceFolderType#VALUES}, but it can also be |
| * defined inline via {@code @+id} in {@link ResourceFolderType#LAYOUT} and |
| * {@link ResourceFolderType#MENU} folders. |
| * |
| * @param type the resource type |
| * @return the corresponding resource folder type |
| */ |
| @NonNull |
| public static ResourceFolderType getFolderTypeFor(@NonNull ResourceType type) { |
| switch (type) { |
| case ANIM: |
| return ResourceFolderType.ANIM; |
| case ANIMATOR: |
| return ResourceFolderType.ANIMATOR; |
| case ARRAY: |
| return ResourceFolderType.VALUES; |
| case COLOR: |
| return ResourceFolderType.COLOR; |
| case DRAWABLE: |
| return ResourceFolderType.DRAWABLE; |
| case INTERPOLATOR: |
| return ResourceFolderType.INTERPOLATOR; |
| case LAYOUT: |
| return ResourceFolderType.LAYOUT; |
| case MENU: |
| return ResourceFolderType.MENU; |
| case MIPMAP: |
| return ResourceFolderType.MIPMAP; |
| case RAW: |
| return ResourceFolderType.RAW; |
| case XML: |
| return ResourceFolderType.XML; |
| case ATTR: |
| case BOOL: |
| case DECLARE_STYLEABLE: |
| case DIMEN: |
| case FRACTION: |
| case ID: |
| case INTEGER: |
| case PLURALS: |
| case PUBLIC: |
| case STRING: |
| case STYLE: |
| case STYLEABLE: |
| return ResourceFolderType.VALUES; |
| default: |
| assert false : type; |
| return ResourceFolderType.VALUES; |
| |
| } |
| } |
| |
| /** |
| * Looks up the {@link ResourceType} defined in a given {@link ResourceFolderType}. |
| * <p> |
| * Note that for {@link ResourceFolderType#VALUES} there are many, many |
| * different types of resources that can be defined, so this method returns |
| * {@code null} for that scenario. |
| * <p> |
| * Note also that {@link ResourceType#ID} is a special case: it can not just |
| * be defined in {@link ResourceFolderType#VALUES}, but it can also be |
| * defined inline via {@code @+id} in {@link ResourceFolderType#LAYOUT} and |
| * {@link ResourceFolderType#MENU} folders. |
| * |
| * @param folderType the resource folder type |
| * @return the corresponding resource type, or null if {@code folderType} is |
| * {@link ResourceFolderType#VALUES} |
| */ |
| @Nullable |
| public static ResourceType getResourceTypeFor(@NonNull ResourceFolderType folderType) { |
| switch (folderType) { |
| case ANIM: |
| return ResourceType.ANIM; |
| case ANIMATOR: |
| return ResourceType.ANIMATOR; |
| case COLOR: |
| return ResourceType.COLOR; |
| case DRAWABLE: |
| return ResourceType.DRAWABLE; |
| case INTERPOLATOR: |
| return ResourceType.INTERPOLATOR; |
| case LAYOUT: |
| return ResourceType.LAYOUT; |
| case MENU: |
| return ResourceType.MENU; |
| case MIPMAP: |
| return ResourceType.MIPMAP; |
| case RAW: |
| return ResourceType.RAW; |
| case XML: |
| return ResourceType.XML; |
| case VALUES: |
| return null; |
| default: |
| assert false : folderType; |
| return null; |
| } |
| } |
| } |
