| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ide.eclipse.adt.internal.editors.manifest; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_NAME; |
| import static com.android.ide.eclipse.adt.internal.editors.manifest.descriptors.AndroidManifestDescriptors.USES_PERMISSION; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.descriptors.AndroidManifestDescriptors; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.pages.ApplicationPage; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.pages.InstrumentationPage; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.pages.OverviewPage; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.pages.PermissionPage; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| import com.android.ide.eclipse.adt.internal.lint.EclipseLintClient; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IFileListener; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IMarkerDelta; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceDelta; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.text.Region; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| import java.util.Collection; |
| import java.util.List; |
| |
| /** |
| * Multi-page form editor for AndroidManifest.xml. |
| */ |
| @SuppressWarnings("restriction") |
| public final class ManifestEditor extends AndroidXmlEditor { |
| |
| public static final String ID = AdtConstants.EDITORS_NAMESPACE + ".manifest.ManifestEditor"; //$NON-NLS-1$ |
| |
| private final static String EMPTY = ""; //$NON-NLS-1$ |
| |
| /** Root node of the UI element hierarchy */ |
| private UiElementNode mUiManifestNode; |
| /** The Application Page tab */ |
| private ApplicationPage mAppPage; |
| /** The Overview Manifest Page tab */ |
| private OverviewPage mOverviewPage; |
| /** The Permission Page tab */ |
| private PermissionPage mPermissionPage; |
| /** The Instrumentation Page tab */ |
| private InstrumentationPage mInstrumentationPage; |
| |
| private IFileListener mMarkerMonitor; |
| |
| |
| /** |
| * Creates the form editor for AndroidManifest.xml. |
| */ |
| public ManifestEditor() { |
| super(); |
| addDefaultTargetListener(); |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| |
| GlobalProjectMonitor.getMonitor().removeFileListener(mMarkerMonitor); |
| } |
| |
| @Override |
| public void activated() { |
| super.activated(); |
| clearActionBindings(false); |
| } |
| |
| @Override |
| public void deactivated() { |
| super.deactivated(); |
| updateActionBindings(); |
| } |
| |
| @Override |
| protected void pageChange(int newPageIndex) { |
| super.pageChange(newPageIndex); |
| if (newPageIndex == mTextPageIndex) { |
| updateActionBindings(); |
| } else { |
| clearActionBindings(false); |
| } |
| } |
| |
| @Override |
| protected int getPersistenceCategory() { |
| return CATEGORY_MANIFEST; |
| } |
| |
| /** |
| * Return the root node of the UI element hierarchy, which here |
| * is the "manifest" node. |
| */ |
| @Override |
| public UiElementNode getUiRootNode() { |
| return mUiManifestNode; |
| } |
| |
| /** |
| * Returns the Manifest descriptors for the file being edited. |
| */ |
| public AndroidManifestDescriptors getManifestDescriptors() { |
| AndroidTargetData data = getTargetData(); |
| if (data != null) { |
| return data.getManifestDescriptors(); |
| } |
| |
| return null; |
| } |
| |
| // ---- Base Class Overrides ---- |
| |
| /** |
| * Returns whether the "save as" operation is supported by this editor. |
| * <p/> |
| * Save-As is a valid operation for the ManifestEditor since it acts on a |
| * single source file. |
| * |
| * @see IEditorPart |
| */ |
| @Override |
| public boolean isSaveAsAllowed() { |
| return true; |
| } |
| |
| @Override |
| public void doSave(IProgressMonitor monitor) { |
| // Look up the current (pre-save) values of minSdkVersion and targetSdkVersion |
| int prevMinSdkVersion = -1; |
| int prevTargetSdkVersion = -1; |
| IProject project = null; |
| ManifestInfo info = null; |
| try { |
| project = getProject(); |
| if (project != null) { |
| info = ManifestInfo.get(project); |
| prevMinSdkVersion = info.getMinSdkVersion(); |
| prevTargetSdkVersion = info.getTargetSdkVersion(); |
| info.clear(); |
| } |
| } catch (Throwable t) { |
| // We don't expect exceptions from the above calls, but we *really* |
| // need to make sure that nothing can prevent the save function from |
| // getting called! |
| AdtPlugin.log(t, null); |
| } |
| |
| // Actually save |
| super.doSave(monitor); |
| |
| // If the target/minSdkVersion has changed, clear all lint warnings (since many |
| // of them are tied to the min/target sdk levels), in order to avoid showing stale |
| // results |
| try { |
| if (info != null) { |
| int newMinSdkVersion = info.getMinSdkVersion(); |
| int newTargetSdkVersion = info.getTargetSdkVersion(); |
| if (newMinSdkVersion != prevMinSdkVersion |
| || newTargetSdkVersion != prevTargetSdkVersion) { |
| assert project != null; |
| EclipseLintClient.clearMarkers(project); |
| } |
| } |
| } catch (Throwable t) { |
| AdtPlugin.log(t, null); |
| } |
| } |
| |
| /** |
| * Creates the various form pages. |
| */ |
| @Override |
| protected void createFormPages() { |
| try { |
| addPage(mOverviewPage = new OverviewPage(this)); |
| addPage(mAppPage = new ApplicationPage(this)); |
| addPage(mPermissionPage = new PermissionPage(this)); |
| addPage(mInstrumentationPage = new InstrumentationPage(this)); |
| } catch (PartInitException e) { |
| AdtPlugin.log(e, "Error creating nested page"); //$NON-NLS-1$ |
| } |
| } |
| |
| /* (non-java doc) |
| * Change the tab/title name to include the project name. |
| */ |
| @Override |
| protected void setInput(IEditorInput input) { |
| super.setInput(input); |
| IFile inputFile = getInputFile(); |
| if (inputFile != null) { |
| startMonitoringMarkers(); |
| setPartName(String.format("%1$s Manifest", inputFile.getProject().getName())); |
| } |
| } |
| |
| /** |
| * Processes the new XML Model, which XML root node is given. |
| * |
| * @param xml_doc The XML document, if available, or null if none exists. |
| */ |
| @Override |
| protected void xmlModelChanged(Document xml_doc) { |
| // create the ui root node on demand. |
| initUiRootNode(false /*force*/); |
| |
| loadFromXml(xml_doc); |
| } |
| |
| private void loadFromXml(Document xmlDoc) { |
| mUiManifestNode.setXmlDocument(xmlDoc); |
| Node node = getManifestXmlNode(xmlDoc); |
| |
| if (node != null) { |
| // Refresh the manifest UI node and all its descendants |
| mUiManifestNode.loadFromXmlNode(node); |
| } |
| } |
| |
| private Node getManifestXmlNode(Document xmlDoc) { |
| if (xmlDoc != null) { |
| ElementDescriptor manifestDesc = mUiManifestNode.getDescriptor(); |
| String manifestXmlName = manifestDesc == null ? null : manifestDesc.getXmlName(); |
| assert manifestXmlName != null; |
| |
| if (manifestXmlName != null) { |
| Node node = xmlDoc.getDocumentElement(); |
| if (node != null && manifestXmlName.equals(node.getNodeName())) { |
| return node; |
| } |
| |
| for (node = xmlDoc.getFirstChild(); |
| node != null; |
| node = node.getNextSibling()) { |
| if (node.getNodeType() == Node.ELEMENT_NODE && |
| manifestXmlName.equals(node.getNodeName())) { |
| return node; |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private void onDescriptorsChanged() { |
| IStructuredModel model = getModelForRead(); |
| if (model != null) { |
| try { |
| Node node = getManifestXmlNode(getXmlDocument(model)); |
| mUiManifestNode.reloadFromXmlNode(node); |
| } finally { |
| model.releaseFromRead(); |
| } |
| } |
| |
| if (mOverviewPage != null) { |
| mOverviewPage.refreshUiApplicationNode(); |
| } |
| |
| if (mAppPage != null) { |
| mAppPage.refreshUiApplicationNode(); |
| } |
| |
| if (mPermissionPage != null) { |
| mPermissionPage.refreshUiNode(); |
| } |
| |
| if (mInstrumentationPage != null) { |
| mInstrumentationPage.refreshUiNode(); |
| } |
| } |
| |
| /** |
| * Reads and processes the current markers and adds a listener for marker changes. |
| */ |
| private void startMonitoringMarkers() { |
| final IFile inputFile = getInputFile(); |
| if (inputFile != null) { |
| updateFromExistingMarkers(inputFile); |
| |
| mMarkerMonitor = new IFileListener() { |
| @Override |
| public void fileChanged(@NonNull IFile file, @NonNull IMarkerDelta[] markerDeltas, |
| int kind, @Nullable String extension, int flags, boolean isAndroidProject) { |
| if (isAndroidProject && file.equals(inputFile)) { |
| processMarkerChanges(markerDeltas); |
| } |
| } |
| }; |
| |
| GlobalProjectMonitor.getMonitor().addFileListener( |
| mMarkerMonitor, IResourceDelta.CHANGED); |
| } |
| } |
| |
| /** |
| * Processes the markers of the specified {@link IFile} and updates the error status of |
| * {@link UiElementNode}s and {@link UiAttributeNode}s. |
| * @param inputFile the file being edited. |
| */ |
| private void updateFromExistingMarkers(IFile inputFile) { |
| try { |
| // get the markers for the file |
| IMarker[] markers = inputFile.findMarkers( |
| AdtConstants.MARKER_ANDROID, true, IResource.DEPTH_ZERO); |
| |
| AndroidManifestDescriptors desc = getManifestDescriptors(); |
| if (desc != null) { |
| ElementDescriptor appElement = desc.getApplicationElement(); |
| |
| if (appElement != null && mUiManifestNode != null) { |
| UiElementNode appUiNode = mUiManifestNode.findUiChildNode( |
| appElement.getXmlName()); |
| List<UiElementNode> children = appUiNode.getUiChildren(); |
| |
| for (IMarker marker : markers) { |
| processMarker(marker, children, IResourceDelta.ADDED); |
| } |
| } |
| } |
| |
| } catch (CoreException e) { |
| // findMarkers can throw an exception, in which case, we'll do nothing. |
| } |
| } |
| |
| /** |
| * Processes a {@link IMarker} change. |
| * @param markerDeltas the list of {@link IMarkerDelta} |
| */ |
| private void processMarkerChanges(IMarkerDelta[] markerDeltas) { |
| AndroidManifestDescriptors descriptors = getManifestDescriptors(); |
| if (descriptors != null && descriptors.getApplicationElement() != null) { |
| UiElementNode app_ui_node = mUiManifestNode.findUiChildNode( |
| descriptors.getApplicationElement().getXmlName()); |
| List<UiElementNode> children = app_ui_node.getUiChildren(); |
| |
| for (IMarkerDelta markerDelta : markerDeltas) { |
| processMarker(markerDelta.getMarker(), children, markerDelta.getKind()); |
| } |
| } |
| } |
| |
| /** |
| * Processes a new/old/updated marker. |
| * @param marker The marker being added/removed/changed |
| * @param nodeList the list of activity/service/provider/receiver nodes. |
| * @param kind the change kind. Can be {@link IResourceDelta#ADDED}, |
| * {@link IResourceDelta#REMOVED}, or {@link IResourceDelta#CHANGED} |
| */ |
| private void processMarker(IMarker marker, List<UiElementNode> nodeList, int kind) { |
| // get the data from the marker |
| String nodeType = marker.getAttribute(AdtConstants.MARKER_ATTR_TYPE, EMPTY); |
| if (nodeType == EMPTY) { |
| return; |
| } |
| |
| String className = marker.getAttribute(AdtConstants.MARKER_ATTR_CLASS, EMPTY); |
| if (className == EMPTY) { |
| return; |
| } |
| |
| for (UiElementNode ui_node : nodeList) { |
| if (ui_node.getDescriptor().getXmlName().equals(nodeType)) { |
| for (UiAttributeNode attr : ui_node.getAllUiAttributes()) { |
| if (attr.getDescriptor().getXmlLocalName().equals( |
| AndroidManifestDescriptors.ANDROID_NAME_ATTR)) { |
| if (attr.getCurrentValue().equals(className)) { |
| if (kind == IResourceDelta.REMOVED) { |
| attr.setHasError(false); |
| } else { |
| attr.setHasError(true); |
| } |
| return; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates the initial UI Root Node, including the known mandatory elements. |
| * @param force if true, a new UiManifestNode is recreated even if it already exists. |
| */ |
| @Override |
| protected void initUiRootNode(boolean force) { |
| // The manifest UI node is always created, even if there's no corresponding XML node. |
| if (mUiManifestNode != null && force == false) { |
| return; |
| } |
| |
| AndroidManifestDescriptors manifestDescriptor = getManifestDescriptors(); |
| |
| if (manifestDescriptor != null) { |
| ElementDescriptor manifestElement = manifestDescriptor.getManifestElement(); |
| mUiManifestNode = manifestElement.createUiNode(); |
| mUiManifestNode.setEditor(this); |
| |
| // Similarly, always create the /manifest/uses-sdk followed by /manifest/application |
| // (order of the elements now matters) |
| ElementDescriptor element = manifestDescriptor.getUsesSdkElement(); |
| boolean present = false; |
| for (UiElementNode ui_node : mUiManifestNode.getUiChildren()) { |
| if (ui_node.getDescriptor() == element) { |
| present = true; |
| break; |
| } |
| } |
| if (!present) { |
| mUiManifestNode.appendNewUiChild(element); |
| } |
| |
| element = manifestDescriptor.getApplicationElement(); |
| present = false; |
| for (UiElementNode ui_node : mUiManifestNode.getUiChildren()) { |
| if (ui_node.getDescriptor() == element) { |
| present = true; |
| break; |
| } |
| } |
| if (!present) { |
| mUiManifestNode.appendNewUiChild(element); |
| } |
| |
| onDescriptorsChanged(); |
| } else { |
| // create a dummy descriptor/uinode until we have real descriptors |
| ElementDescriptor desc = new ElementDescriptor("manifest", //$NON-NLS-1$ |
| "temporary descriptors due to missing decriptors", //$NON-NLS-1$ |
| null /*tooltip*/, null /*sdk_url*/, null /*attributes*/, |
| null /*children*/, false /*mandatory*/); |
| mUiManifestNode = desc.createUiNode(); |
| mUiManifestNode.setEditor(this); |
| } |
| } |
| |
| /** |
| * Adds the given set of permissions into the manifest file in the suitable |
| * location |
| * |
| * @param permissions permission fqcn's to be added |
| * @param show if true, show one or more of the newly added permissions |
| */ |
| public void addPermissions(@NonNull final List<String> permissions, final boolean show) { |
| wrapUndoEditXmlModel("Add permissions", new Runnable() { |
| @Override |
| public void run() { |
| // Ensure that the model is current: |
| initUiRootNode(true /*force*/); |
| UiElementNode root = getUiRootNode(); |
| |
| ElementDescriptor descriptor = getManifestDescriptors().getUsesPermissionElement(); |
| boolean shown = false; |
| for (String permission : permissions) { |
| // Find the first permission which sorts alphabetically laster than |
| // this permission (or the last permission, if none are after in the alphabet) |
| // and insert it there |
| int lastPermissionIndex = -1; |
| int nextPermissionIndex = -1; |
| int index = 0; |
| for (UiElementNode sibling : root.getUiChildren()) { |
| Node node = sibling.getXmlNode(); |
| if (node.getNodeName().equals(USES_PERMISSION)) { |
| lastPermissionIndex = index; |
| String name = ((Element) node).getAttributeNS(ANDROID_URI, ATTR_NAME); |
| if (permission.compareTo(name) < 0) { |
| nextPermissionIndex = index; |
| break; |
| } |
| } else if (node.getNodeName().equals("application")) { //$NON-NLS-1$ |
| // permissions should come before the application element |
| nextPermissionIndex = index; |
| break; |
| } |
| index++; |
| } |
| |
| if (nextPermissionIndex != -1) { |
| index = nextPermissionIndex; |
| } else if (lastPermissionIndex != -1) { |
| index = lastPermissionIndex + 1; |
| } else { |
| index = root.getUiChildren().size(); |
| } |
| UiElementNode usesPermission = root.insertNewUiChild(index, descriptor); |
| usesPermission.setAttributeValue(ATTR_NAME, ANDROID_URI, permission, |
| true /*override*/); |
| Node node = usesPermission.createXmlNode(); |
| if (show && !shown) { |
| shown = true; |
| if (node instanceof IndexedRegion && getInputFile() != null) { |
| IndexedRegion indexedRegion = (IndexedRegion) node; |
| IRegion region = new Region(indexedRegion.getStartOffset(), |
| indexedRegion.getEndOffset() - indexedRegion.getStartOffset()); |
| try { |
| AdtPlugin.openFile(getInputFile(), region, true /*show*/); |
| } catch (PartInitException e) { |
| AdtPlugin.log(e, null); |
| } |
| } else { |
| show(node); |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Removes the permissions from the manifest editor |
| * |
| * @param permissions the permission fqcn's to be removed |
| */ |
| public void removePermissions(@NonNull final Collection<String> permissions) { |
| wrapUndoEditXmlModel("Remove permissions", new Runnable() { |
| @Override |
| public void run() { |
| // Ensure that the model is current: |
| initUiRootNode(true /*force*/); |
| UiElementNode root = getUiRootNode(); |
| |
| for (String permission : permissions) { |
| for (UiElementNode sibling : root.getUiChildren()) { |
| Node node = sibling.getXmlNode(); |
| if (node.getNodeName().equals(USES_PERMISSION)) { |
| String name = ((Element) node).getAttributeNS(ANDROID_URI, ATTR_NAME); |
| if (name.equals(permission)) { |
| sibling.deleteXmlNode(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| } |
