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.layout.gre; import static com.android.SdkConstants.ANDROID_URI; import static com.android.SdkConstants.ATTR_ID; import static com.android.SdkConstants.AUTO_URI; import static com.android.SdkConstants.CLASS_FRAGMENT; import static com.android.SdkConstants.CLASS_V4_FRAGMENT; import static com.android.SdkConstants.NEW_ID_PREFIX; import static com.android.SdkConstants.URI_PREFIX; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.ide.common.api.IClientRulesEngine; import com.android.ide.common.api.INode; import com.android.ide.common.api.IValidator; import com.android.ide.common.api.IViewMetadata; import com.android.ide.common.api.IViewRule; import com.android.ide.common.api.Margins; import com.android.ide.common.api.Rect; import com.android.ide.common.layout.BaseViewRule; import com.android.ide.common.resources.ResourceRepository; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.actions.AddSupportJarAction; import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.LayoutCanvas; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderService; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SelectionManager; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.ViewHierarchy; import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; import com.android.ide.eclipse.adt.internal.refactorings.core.RenameResult; import com.android.ide.eclipse.adt.internal.resources.CyclicDependencyValidator; import com.android.ide.eclipse.adt.internal.resources.ResourceNameValidator; import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; import com.android.ide.eclipse.adt.internal.sdk.ProjectState; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.ide.eclipse.adt.internal.ui.MarginChooser; import com.android.ide.eclipse.adt.internal.ui.ReferenceChooserDialog; import com.android.ide.eclipse.adt.internal.ui.ResourceChooser; import com.android.ide.eclipse.adt.internal.ui.ResourcePreviewHelper; import com.android.resources.ResourceType; import com.android.sdklib.IAndroidTarget; import org.eclipse.core.resources.IProject; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IJavaProject; 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.JavaModelException; import org.eclipse.jdt.core.search.IJavaSearchScope; import org.eclipse.jdt.core.search.SearchEngine; import org.eclipse.jdt.ui.IJavaElementSearchConstants; import org.eclipse.jdt.ui.JavaUI; import org.eclipse.jdt.ui.actions.OpenNewClassWizardAction; import org.eclipse.jdt.ui.dialogs.ITypeInfoFilterExtension; import org.eclipse.jdt.ui.dialogs.ITypeInfoRequestor; import org.eclipse.jdt.ui.dialogs.TypeSelectionExtension; import org.eclipse.jdt.ui.wizards.NewClassWizardPage; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.IInputValidator; import org.eclipse.jface.dialogs.InputDialog; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.dialogs.ProgressMonitorDialog; import org.eclipse.jface.window.Window; import org.eclipse.swt.SWT; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.dialogs.SelectionDialog; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; /** * Implementation of {@link IClientRulesEngine}. This provides {@link IViewRule} clients * with a few methods they can use to access functionality from this {@link RulesEngine}. */ class ClientRulesEngine implements IClientRulesEngine { /** The return code from the dialog for the user choosing "Clear" */ public static final int CLEAR_RETURN_CODE = -5; /** The dialog button ID for the user choosing "Clear" */ private static final int CLEAR_BUTTON_ID = CLEAR_RETURN_CODE; private final RulesEngine mRulesEngine; private final String mFqcn; public ClientRulesEngine(RulesEngine rulesEngine, String fqcn) { mRulesEngine = rulesEngine; mFqcn = fqcn; } @Override public @NonNull String getFqcn() { return mFqcn; } @Override public void debugPrintf(@NonNull String msg, Object... params) { AdtPlugin.printToConsole(mFqcn == null ? "<unknown>" : mFqcn, String.format(msg, params)); } @Override public IViewRule loadRule(@NonNull String fqcn) { return mRulesEngine.loadRule(fqcn, fqcn); } @Override public void displayAlert(@NonNull String message) { MessageDialog.openInformation(AdtPlugin.getShell(), mFqcn, // title message); } @Override public boolean rename(INode node) { GraphicalEditorPart editor = mRulesEngine.getEditor(); SelectionManager manager = editor.getCanvasControl().getSelectionManager(); RenameResult result = manager.performRename(node, null); return !result.isCanceled() && !result.isUnavailable(); } @Override public String displayInput(@NonNull String message, @Nullable String value, final @Nullable IValidator filter) { IInputValidator validator = null; if (filter != null) { validator = new IInputValidator() { @Override public String isValid(String newText) { // IValidator has the same interface as SWT's IInputValidator try { return filter.validate(newText); } catch (Exception e) { AdtPlugin.log(e, "Custom validator failed: %s", e.toString()); return ""; //$NON-NLS-1$ } } }; } InputDialog d = new InputDialog(AdtPlugin.getShell(), mFqcn, // title message, value == null ? "" : value, //$NON-NLS-1$ validator) { @Override protected void createButtonsForButtonBar(Composite parent) { createButton(parent, CLEAR_BUTTON_ID, "Clear", false /*defaultButton*/); super.createButtonsForButtonBar(parent); } @Override protected void buttonPressed(int buttonId) { super.buttonPressed(buttonId); if (buttonId == CLEAR_BUTTON_ID) { assert CLEAR_RETURN_CODE != Window.OK && CLEAR_RETURN_CODE != Window.CANCEL; setReturnCode(CLEAR_RETURN_CODE); close(); } } }; int result = d.open(); if (result == ResourceChooser.CLEAR_RETURN_CODE) { return ""; } else if (result == Window.OK) { return d.getValue(); } return null; } @Override @Nullable public Object getViewObject(@NonNull INode node) { ViewHierarchy views = mRulesEngine.getEditor().getCanvasControl().getViewHierarchy(); CanvasViewInfo vi = views.findViewInfoFor(node); if (vi != null) { return vi.getViewObject(); } return null; } @Override public @NonNull IViewMetadata getMetadata(final @NonNull String fqcn) { return new IViewMetadata() { @Override public @NonNull String getDisplayName() { // This also works when there is no "." return fqcn.substring(fqcn.lastIndexOf('.') + 1); } @Override public @NonNull FillPreference getFillPreference() { return ViewMetadataRepository.get().getFillPreference(fqcn); } @Override public @NonNull Margins getInsets() { return mRulesEngine.getEditor().getCanvasControl().getInsets(fqcn); } @Override public @NonNull List<String> getTopAttributes() { return ViewMetadataRepository.get().getTopAttributes(fqcn); } }; } @Override public int getMinApiLevel() { Sdk currentSdk = Sdk.getCurrent(); if (currentSdk != null) { IAndroidTarget target = currentSdk.getTarget(mRulesEngine.getEditor().getProject()); if (target != null) { return target.getVersion().getApiLevel(); } } return -1; } @Override public IValidator getResourceValidator(@NonNull final String resourceTypeName, final boolean uniqueInProject, final boolean uniqueInLayout, final boolean exists, final String... allowed) { return new IValidator() { private ResourceNameValidator mValidator; @Override public String validate(@NonNull String text) { if (mValidator == null) { ResourceType type = ResourceType.getEnum(resourceTypeName); if (uniqueInLayout) { assert !uniqueInProject; assert !exists; Set<String> existing = new HashSet<String>(); Document doc = mRulesEngine.getEditor().getModel().getXmlDocument(); if (doc != null) { addIds(doc, existing); } for (String s : allowed) { existing.remove(s); } mValidator = ResourceNameValidator.create(false, existing, type); } else { assert allowed.length == 0; IProject project = mRulesEngine.getEditor().getProject(); mValidator = ResourceNameValidator.create(false, project, type); if (uniqueInProject) { mValidator.unique(); } } if (exists) { mValidator.exist(); } } return mValidator.isValid(text); } }; } /** Find declared ids under the given DOM node */ private static void addIds(Node node, Set<String> ids) { if (node.getNodeType() == Node.ELEMENT_NODE) { Element element = (Element) node; String id = element.getAttributeNS(ANDROID_URI, ATTR_ID); if (id != null && id.startsWith(NEW_ID_PREFIX)) { ids.add(BaseViewRule.stripIdPrefix(id)); } } NodeList children = node.getChildNodes(); for (int i = 0, n = children.getLength(); i < n; i++) { Node child = children.item(i); addIds(child, ids); } } @Override public String displayReferenceInput(@Nullable String currentValue) { GraphicalEditorPart graphicalEditor = mRulesEngine.getEditor(); LayoutEditorDelegate delegate = graphicalEditor.getEditorDelegate(); IProject project = delegate.getEditor().getProject(); if (project != null) { // get the resource repository for this project and the system resources. ResourceRepository projectRepository = ResourceManager.getInstance().getProjectResources(project); Shell shell = AdtPlugin.getShell(); if (shell == null) { return null; } ReferenceChooserDialog dlg = new ReferenceChooserDialog(project, projectRepository, shell); dlg.setPreviewHelper(new ResourcePreviewHelper(dlg, graphicalEditor)); dlg.setCurrentResource(currentValue); if (dlg.open() == Window.OK) { return dlg.getCurrentResource(); } } return null; } @Override public String displayResourceInput(@NonNull String resourceTypeName, @Nullable String currentValue) { return displayResourceInput(resourceTypeName, currentValue, null); } private String displayResourceInput(String resourceTypeName, String currentValue, IInputValidator validator) { ResourceType type = ResourceType.getEnum(resourceTypeName); GraphicalEditorPart graphicalEditor = mRulesEngine.getEditor(); return ResourceChooser.chooseResource(graphicalEditor, type, currentValue, validator); } @Override public String[] displayMarginInput(@Nullable String all, @Nullable String left, @Nullable String right, @Nullable String top, @Nullable String bottom) { GraphicalEditorPart editor = mRulesEngine.getEditor(); IProject project = editor.getProject(); if (project != null) { Shell shell = AdtPlugin.getShell(); if (shell == null) { return null; } AndroidTargetData data = editor.getEditorDelegate().getEditor().getTargetData(); MarginChooser dialog = new MarginChooser(shell, editor, data, all, left, right, top, bottom); if (dialog.open() == Window.OK) { return dialog.getMargins(); } } return null; } @Override public String displayIncludeSourceInput() { AndroidXmlEditor editor = mRulesEngine.getEditor().getEditorDelegate().getEditor(); IInputValidator validator = CyclicDependencyValidator.create(editor.getInputFile()); return displayResourceInput(ResourceType.LAYOUT.getName(), null, validator); } @Override public void select(final @NonNull Collection<INode> nodes) { LayoutCanvas layoutCanvas = mRulesEngine.getEditor().getCanvasControl(); final SelectionManager selectionManager = layoutCanvas.getSelectionManager(); selectionManager.select(nodes); // ALSO run an async select since immediately after nodes are created they // may not be selectable. We can't ONLY run an async exec since // code may depend on operating on the selection. layoutCanvas.getDisplay().asyncExec(new Runnable() { @Override public void run() { selectionManager.select(nodes); } }); } @Override public String displayFragmentSourceInput() { try { // Compute a search scope: We need to merge all the subclasses // android.app.Fragment and android.support.v4.app.Fragment IJavaSearchScope scope = SearchEngine.createWorkspaceScope(); IProject project = mRulesEngine.getProject(); final IJavaProject javaProject = BaseProjectHelper.getJavaProject(project); if (javaProject != null) { IType oldFragmentType = javaProject.findType(CLASS_V4_FRAGMENT); // First check to make sure fragments are available, and if not, // warn the user. IAndroidTarget target = Sdk.getCurrent().getTarget(project); // No, this should be using the min SDK instead! if (target.getVersion().getApiLevel() < 11 && oldFragmentType == null) { // Compatibility library must be present MessageDialog dialog = new MessageDialog(Display.getCurrent().getActiveShell(), "Fragment Warning", null, "Fragments require API level 11 or higher, or a compatibility " + "library for older versions.\n\n" + " Do you want to install the compatibility library?", MessageDialog.QUESTION, new String[] { "Install", "Cancel" }, 1 /* default button: Cancel */); int answer = dialog.open(); if (answer == 0) { if (!AddSupportJarAction.install(project)) { return null; } } else { return null; } } // Look up sub-types of each (new fragment class and compatibility fragment // class, if any) and merge the two arrays - then create a scope from these // elements. IType[] fragmentTypes = new IType[0]; IType[] oldFragmentTypes = new IType[0]; if (oldFragmentType != null) { ITypeHierarchy hierarchy = oldFragmentType.newTypeHierarchy(new NullProgressMonitor()); oldFragmentTypes = hierarchy.getAllSubtypes(oldFragmentType); } IType fragmentType = javaProject.findType(CLASS_FRAGMENT); if (fragmentType != null) { ITypeHierarchy hierarchy = fragmentType.newTypeHierarchy(new NullProgressMonitor()); fragmentTypes = hierarchy.getAllSubtypes(fragmentType); } IType[] subTypes = new IType[fragmentTypes.length + oldFragmentTypes.length]; System.arraycopy(fragmentTypes, 0, subTypes, 0, fragmentTypes.length); System.arraycopy(oldFragmentTypes, 0, subTypes, fragmentTypes.length, oldFragmentTypes.length); scope = SearchEngine.createJavaSearchScope(subTypes, IJavaSearchScope.SOURCES); } Shell parent = AdtPlugin.getShell(); final AtomicReference<String> returnValue = new AtomicReference<String>(); final AtomicReference<SelectionDialog> dialogHolder = new AtomicReference<SelectionDialog>(); final SelectionDialog dialog = JavaUI.createTypeDialog(parent, new ProgressMonitorDialog(parent), scope, IJavaElementSearchConstants.CONSIDER_CLASSES, false, // Use ? as a default filter to fill dialog with matches "?", //$NON-NLS-1$ new TypeSelectionExtension() { @Override public Control createContentArea(Composite parentComposite) { Composite composite = new Composite(parentComposite, SWT.NONE); composite.setLayout(new GridLayout(1, false)); Button button = new Button(composite, SWT.PUSH); button.setText("Create New..."); button.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { String fqcn = createNewFragmentClass(javaProject); if (fqcn != null) { returnValue.set(fqcn); dialogHolder.get().close(); } } }); return composite; } @Override public ITypeInfoFilterExtension getFilterExtension() { return new ITypeInfoFilterExtension() { @Override public boolean select(ITypeInfoRequestor typeInfoRequestor) { int modifiers = typeInfoRequestor.getModifiers(); if (!Flags.isPublic(modifiers) || Flags.isInterface(modifiers) || Flags.isEnum(modifiers)) { return false; } return true; } }; } }); dialogHolder.set(dialog); dialog.setTitle("Choose Fragment Class"); dialog.setMessage("Select a Fragment class (? = any character, * = any string):"); if (dialog.open() == IDialogConstants.CANCEL_ID) { return null; } if (returnValue.get() != null) { return returnValue.get(); } Object[] types = dialog.getResult(); if (types != null && types.length > 0) { return ((IType) types[0]).getFullyQualifiedName(); } } catch (JavaModelException e) { AdtPlugin.log(e, null); } catch (CoreException e) { AdtPlugin.log(e, null); } return null; } @Override public void redraw() { mRulesEngine.getEditor().getCanvasControl().redraw(); } @Override public void layout() { mRulesEngine.getEditor().recomputeLayout(); } @Override public Map<INode, Rect> measureChildren(@NonNull INode parent, @Nullable IClientRulesEngine.AttributeFilter filter) { RenderService renderService = RenderService.create(mRulesEngine.getEditor()); Map<INode, Rect> map = renderService.measureChildren(parent, filter); if (map == null) { map = Collections.emptyMap(); } return map; } @Override public int pxToDp(int px) { ConfigurationChooser chooser = mRulesEngine.getEditor().getConfigurationChooser(); float dpi = chooser.getConfiguration().getDensity().getDpiValue(); return (int) (px * 160 / dpi); } @Override public int dpToPx(int dp) { ConfigurationChooser chooser = mRulesEngine.getEditor().getConfigurationChooser(); float dpi = chooser.getConfiguration().getDensity().getDpiValue(); return (int) (dp * dpi / 160); } @Override public int screenToLayout(int pixels) { return (int) (pixels / mRulesEngine.getEditor().getCanvasControl().getScale()); } String createNewFragmentClass(IJavaProject javaProject) { NewClassWizardPage page = new NewClassWizardPage(); IProject project = mRulesEngine.getProject(); IAndroidTarget target = Sdk.getCurrent().getTarget(project); String superClass; if (target.getVersion().getApiLevel() < 11) { superClass = CLASS_V4_FRAGMENT; } else { superClass = CLASS_FRAGMENT; } page.setSuperClass(superClass, true /* canBeModified */); IPackageFragmentRoot root = ManifestInfo.getSourcePackageRoot(javaProject); if (root != null) { page.setPackageFragmentRoot(root, true /* canBeModified */); } ManifestInfo manifestInfo = ManifestInfo.get(project); IPackageFragment pkg = manifestInfo.getPackageFragment(); if (pkg != null) { page.setPackageFragment(pkg, true /* canBeModified */); } OpenNewClassWizardAction action = new OpenNewClassWizardAction(); action.setConfiguredWizardPage(page); action.run(); IType createdType = page.getCreatedType(); if (createdType != null) { return createdType.getFullyQualifiedName(); } else { return null; } } @Override public @NonNull String getUniqueId(@NonNull String fqcn) { UiDocumentNode root = mRulesEngine.getEditor().getModel(); String prefix = fqcn.substring(fqcn.lastIndexOf('.') + 1); prefix = Character.toLowerCase(prefix.charAt(0)) + prefix.substring(1); return DescriptorsUtils.getFreeWidgetId(root, prefix); } @Override public @NonNull String getAppNameSpace() { IProject project = mRulesEngine.getEditor().getProject(); ProjectState projectState = Sdk.getProjectState(project); if (projectState != null && projectState.isLibrary()) { return AUTO_URI; } ManifestInfo info = ManifestInfo.get(project); return URI_PREFIX + info.getPackage(); } }