diff options
Diffstat (limited to 'src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java')
| -rw-r--r-- | src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java | 1099 |
1 files changed, 1099 insertions, 0 deletions
diff --git a/src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java b/src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java new file mode 100644 index 0000000..0cd1e25 --- /dev/null +++ b/src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java @@ -0,0 +1,1099 @@ +/* +* Copyright (C) 2012 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 +* +* 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.motorola.studio.android.model.manifest.parser; + +import java.util.LinkedList; +import java.util.List; + +import org.eclipse.osgi.util.NLS; +import org.w3c.dom.Comment; +import org.w3c.dom.NamedNodeMap; + +import com.motorola.studio.android.common.log.StudioLogger; +import com.motorola.studio.android.common.utilities.i18n.UtilitiesNLS; +import com.motorola.studio.android.model.manifest.dom.AbstractBuildingBlockNode; +import com.motorola.studio.android.model.manifest.dom.AbstractIconLabelNameNode; +import com.motorola.studio.android.model.manifest.dom.AbstractSimpleNameNode; +import com.motorola.studio.android.model.manifest.dom.ActionNode; +import com.motorola.studio.android.model.manifest.dom.ActivityAliasNode; +import com.motorola.studio.android.model.manifest.dom.ActivityNode; +import com.motorola.studio.android.model.manifest.dom.ApplicationNode; +import com.motorola.studio.android.model.manifest.dom.CategoryNode; +import com.motorola.studio.android.model.manifest.dom.CommentNode; +import com.motorola.studio.android.model.manifest.dom.DataNode; +import com.motorola.studio.android.model.manifest.dom.GrantUriPermissionNode; +import com.motorola.studio.android.model.manifest.dom.IAndroidManifestProperties; +import com.motorola.studio.android.model.manifest.dom.InstrumentationNode; +import com.motorola.studio.android.model.manifest.dom.IntentFilterNode; +import com.motorola.studio.android.model.manifest.dom.ManifestNode; +import com.motorola.studio.android.model.manifest.dom.MetadataNode; +import com.motorola.studio.android.model.manifest.dom.PermissionGroupNode; +import com.motorola.studio.android.model.manifest.dom.PermissionNode; +import com.motorola.studio.android.model.manifest.dom.PermissionTreeNode; +import com.motorola.studio.android.model.manifest.dom.ProviderNode; +import com.motorola.studio.android.model.manifest.dom.ReceiverNode; +import com.motorola.studio.android.model.manifest.dom.ServiceNode; +import com.motorola.studio.android.model.manifest.dom.UnknownNode; +import com.motorola.studio.android.model.manifest.dom.UsesFeatureNode; +import com.motorola.studio.android.model.manifest.dom.UsesLibraryNode; +import com.motorola.studio.android.model.manifest.dom.UsesPermissionNode; +import com.motorola.studio.android.model.manifest.dom.UsesSDKNode; + +/** + * Abstract class that contains methods to parse the AndroidManifest.xml file nodes + */ +abstract class AndroidManifestNodeParser implements IAndroidManifestProperties +{ + /** + * Errors when parsing + */ + protected final List<String> parseErrors; + + /** + * Default constructor + */ + public AndroidManifestNodeParser() + { + parseErrors = new LinkedList<String>(); + } + + /** + * Parses a <manifest> node + * + * @param attributes The node attributes + * @return a ManifestNode object corresponding to the node + */ + protected ManifestNode parseManifestNode(NamedNodeMap attributes) + { + ManifestNode manifestNode = new ManifestNode(""); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_PACKAGE)) + { + manifestNode.setPackage(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_SHAREDUSERID)) + { + manifestNode.setSharedUserId(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_VERSIONCODE)) + { + Integer versionCode; + + try + { + versionCode = Integer.parseInt(attrValue); + } + catch (NumberFormatException nfe) + { + versionCode = 1; + String errMsg = + NLS.bind( + UtilitiesNLS.ERR_AndroidManifestNodeParser_ErrorParsingVersionCode, + attrValue, versionCode.toString()); + parseErrors.add(errMsg); + StudioLogger.error(AndroidManifestNodeParser.class, errMsg, nfe); + } + + manifestNode.setVersionCode(versionCode); + } + else if (attrName.equalsIgnoreCase(PROP_VERSIONNAME)) + { + manifestNode.setVersionName(attrValue); + } + else if (!attrName.equalsIgnoreCase(PROP_XMLNS)) + { + manifestNode.addUnknownProperty(attrName, attrValue); + } + } + + return manifestNode; + } + + /** + * Parses an <uses-permission> node + * + * @param attributes The node attributes + * @return a UsesPermissionNode object corresponding to the node + */ + protected UsesPermissionNode parseUsesPermissionNode(NamedNodeMap attributes) + { + UsesPermissionNode usesPermissionNode = new UsesPermissionNode(""); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_NAME)) + { + usesPermissionNode.setName(attrValue); + } + else + { + usesPermissionNode.addUnknownProperty(attrName, attrValue); + } + } + + return usesPermissionNode; + } + + /** + * Parses a <permission> node + * + * @param attributes The node attributes + * @return a PermissionNode object corresponding to the node + */ + protected PermissionNode parsePermissionNode(NamedNodeMap attributes) + { + PermissionNode permissionNode = new PermissionNode(""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, permissionNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_DESCRIPTION)) + { + permissionNode.setDescription(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PERMISSIONGROUP)) + { + permissionNode.setPermissionGroup(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PROTECTIONLEVEL)) + { + permissionNode.setProtectionLevel(PermissionNode.getProtectionLevel(attrValue)); + } + else + { + permissionNode.addUnknownProperty(attrName, attrValue); + } + } + + return permissionNode; + } + + /** + * Parses a <permission-tree> node + * + * @param attributes The node attributes + * @return a PermissionTreeNode object corresponding to the node + */ + protected PermissionTreeNode parsePermissionTreeNode(NamedNodeMap attributes) + { + PermissionTreeNode permissionTreeNode = new PermissionTreeNode(""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, permissionTreeNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + permissionTreeNode.addUnknownProperty(attrName, attrValue); + } + + return permissionTreeNode; + } + + /** + * Parses a <permission-group> node + * + * @param attributes The node attributes + * @return a PermissionGroupNode object corresponding to the node + */ + protected PermissionGroupNode parsePermissionGroupNode(NamedNodeMap attributes) + { + PermissionGroupNode permissionGroupNode = new PermissionGroupNode(""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, permissionGroupNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_DESCRIPTION)) + { + permissionGroupNode.setDescription(attrValue); + } + else + { + permissionGroupNode.addUnknownProperty(attrName, attrValue); + } + } + + return permissionGroupNode; + } + + /** + * Parses an <instrumentation> node + * + * @param attributes The node attributes + * @return an InstrumentationNode object corresponding to the node + */ + protected InstrumentationNode parseInstrumentationNode(NamedNodeMap attributes) + { + InstrumentationNode instrumentationNode = new InstrumentationNode(""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, instrumentationNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_FUNCTIONALTEST)) + { + Boolean functionalTest = Boolean.parseBoolean(attrValue); + instrumentationNode.setFunctionalTest(functionalTest); + } + else if (attrName.equalsIgnoreCase(PROP_HANDLEPROFILING)) + { + Boolean handleProfiling = Boolean.parseBoolean(attrValue); + instrumentationNode.setHandleProfiling(handleProfiling); + } + else if (attrName.equalsIgnoreCase(PROP_TARGETPACKAGE)) + { + instrumentationNode.setTargetPackage(attrValue); + } + else + { + instrumentationNode.addUnknownProperty(attrName, attrValue); + } + } + + return instrumentationNode; + } + + /** + * Parses an <uses-sdk> node + * + * @param attributes The node attributes + * @return an UsesNode object corresponding to the node + */ + protected UsesSDKNode parseUsesSdkNode(NamedNodeMap attributes) + { + UsesSDKNode usesSDKNode = new UsesSDKNode(); + String attrName, attrValue; + String minSdkVersion; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_MINSDKVERSION)) + { + minSdkVersion = attrValue; + usesSDKNode.setMinSdkVersion(minSdkVersion); + } + else if (attrName.equalsIgnoreCase(PROP_MAXSDKVERSION)) + { + usesSDKNode.setPropMaxSdkVersion(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_TARGETSDKVERSION)) + { + usesSDKNode.setPropTargetSdkVersion(attrValue); + } + else + { + usesSDKNode.addUnknownProperty(attrName, attrValue); + } + } + + return usesSDKNode; + } + + /** + * Parses an <application> node + * + * @param attributes The node attributes + * @return an ApplicationNode object corresponding to the node + */ + protected ApplicationNode parseApplicationNode(NamedNodeMap attributes) + { + ApplicationNode applicationNode = new ApplicationNode(""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, applicationNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ALLOWCLEARUSERDATA)) + { + Boolean allowClearUserData = Boolean.parseBoolean(attrValue); + applicationNode.setAllowClearUserData(allowClearUserData); + } + else if (attrName.equalsIgnoreCase(PROP_ALLOWTASKREPARENTING)) + { + Boolean allowTaskReparentig = Boolean.parseBoolean(attrValue); + applicationNode.setAllowTaskReparenting(allowTaskReparentig); + } + else if (attrName.equalsIgnoreCase(PROP_DEBUGGABLE)) + { + Boolean debbugable = Boolean.parseBoolean(attrValue); + applicationNode.setDebuggable(debbugable); + } + else if (attrName.equalsIgnoreCase(PROP_DESCRIPTION)) + { + applicationNode.setDescription(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_ENABLED)) + { + Boolean enabled = Boolean.parseBoolean(attrValue); + applicationNode.setEnabled(enabled); + } + else if (attrName.equalsIgnoreCase(PROP_HASCODE)) + { + Boolean hasCode = Boolean.parseBoolean(attrValue); + applicationNode.setHasCode(hasCode); + } + else if (attrName.equalsIgnoreCase(PROP_MANAGESPACEACTIVITY)) + { + applicationNode.setManageSpaceActivity(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PERMISSION)) + { + applicationNode.setPermission(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PERSISTENT)) + { + Boolean persistent = Boolean.parseBoolean(attrValue); + applicationNode.setPersistent(persistent); + } + else if (attrName.equalsIgnoreCase(PROP_PROCESS)) + { + applicationNode.setProcess(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_TASKAFFINITY)) + { + applicationNode.setTaskAffinity(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_THEME)) + { + applicationNode.setTheme(attrValue); + } + else + { + applicationNode.addUnknownProperty(attrName, attrValue); + } + } + + return applicationNode; + } + + /** + * Parses an <activity> node + * + * @param attributes The node attributes + * @return an ActivityNode object corresponding to the node + */ + protected ActivityNode parseActivityNode(NamedNodeMap attributes) + { + ActivityNode activityNode = new ActivityNode(""); + String attrName, attrValue; + + parseAbstractBuildingBlockNode(attributes, activityNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ALLOWTASKREPARENTING)) + { + Boolean allowTaskReparentig = Boolean.parseBoolean(attrValue); + activityNode.setAllowTaskReparenting(allowTaskReparentig); + } + else if (attrName.equalsIgnoreCase(PROP_ALWAYSRETAINTASKSTATE)) + { + Boolean alwaysRetainTaskState = Boolean.parseBoolean(attrValue); + activityNode.setAlwaysRetainTaskState(alwaysRetainTaskState); + } + else if (attrName.equalsIgnoreCase(PROP_CLEARTASKONLAUNCH)) + { + Boolean clearTaskOnLaunch = Boolean.parseBoolean(attrValue); + activityNode.setClearTaskOnLaunch(clearTaskOnLaunch); + } + else if (attrName.equalsIgnoreCase(PROP_CONFIGCHANGES)) + { + String configChanges[] = attrValue.split("\\|"); + + for (String configChange : configChanges) + { + activityNode.addConfigChanges(ActivityNode + .getConfigChangeFromName(configChange)); + } + } + else if (attrName.equalsIgnoreCase(PROP_EXCLUDEFROMRECENTS)) + { + Boolean excludeFromRecents = Boolean.parseBoolean(attrValue); + activityNode.setExcludeFromRecents(excludeFromRecents); + } + else if (attrName.equalsIgnoreCase(PROP_FINISHONTASKLAUNCH)) + { + Boolean finishOnTaskLaunch = Boolean.parseBoolean(attrValue); + activityNode.setFinishOnTaskLaunch(finishOnTaskLaunch); + } + else if (attrName.equalsIgnoreCase(PROP_LAUNCHMODE)) + { + activityNode.setLaunchMode(ActivityNode.getLaunchModeFromName(attrValue)); + } + else if (attrName.equalsIgnoreCase(PROP_MULTIPROCESS)) + { + Boolean multiprocess = Boolean.parseBoolean(attrValue); + activityNode.setMultiprocess(multiprocess); + } + else if (attrName.equalsIgnoreCase(PROP_SCREENORIENTATION)) + { + activityNode.setScreenOrientation(ActivityNode + .getScreenOrientationFromName(attrValue)); + } + else if (attrName.equalsIgnoreCase(PROP_STATENOTNEEDED)) + { + Boolean stateNotNeeded = Boolean.parseBoolean(attrValue); + activityNode.setStateNotNeeded(stateNotNeeded); + } + else if (attrName.equalsIgnoreCase(PROP_TASKAFFINITY)) + { + activityNode.setTaskAffinity(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_THEME)) + { + activityNode.setTheme(attrValue); + } + else + { + activityNode.addUnknownProperty(attrName, attrValue); + } + } + + return activityNode; + } + + /** + * Parses an <intent-filter> node + * + * @param attributes The node attributes + * @return an IntentFilterNode object corresponding to the node + */ + protected IntentFilterNode parseIntentFilterNode(NamedNodeMap attributes) + { + IntentFilterNode intentFilterNode = new IntentFilterNode(); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ICON)) + { + intentFilterNode.setIcon(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_LABEL)) + { + intentFilterNode.setLabel(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PRIORITY)) + { + try + { + Integer priority = Integer.parseInt(attrValue); + intentFilterNode.setPriority(priority); + } + catch (NumberFormatException nfe) + { + String errMsg = + NLS.bind( + UtilitiesNLS.ERR_AndroidManifestNodeParser_ErrorParsingPriority, + attrValue); + parseErrors.add(errMsg); + StudioLogger.error(AndroidManifestNodeParser.class, errMsg, nfe); + } + } + else + { + intentFilterNode.addUnknownProperty(attrName, attrValue); + } + } + + return intentFilterNode; + } + + /** + * Parses an <action> node + * + * @param attributes The node attributes + * @return an ActionNode object corresponding to the node + */ + protected ActionNode parseActionNode(NamedNodeMap attributes) + { + ActionNode actionNode = new ActionNode(""); + String attrName, attrValue; + + parseAbstractSimpleNameNode(attributes, actionNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + actionNode.addUnknownProperty(attrName, attrValue); + } + + return actionNode; + } + + /** + * Parses a <category> node + * + * @param attributes The node attributes + * @return a CategoryNode object corresponding to the node + */ + protected CategoryNode parseCategoryNode(NamedNodeMap attributes) + { + CategoryNode categoryNode = new CategoryNode(""); + String attrName, attrValue; + + parseAbstractSimpleNameNode(attributes, categoryNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + categoryNode.addUnknownProperty(attrName, attrValue); + } + + return categoryNode; + } + + /** + * Parses a <data> node + * + * @param attributes The node attributes + * @return a DataNode object corresponding to the node + */ + protected DataNode parseDataNode(NamedNodeMap attributes) + { + DataNode dataNode = new DataNode(); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_HOST)) + { + dataNode.setHost(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_MIMETYPE)) + { + dataNode.setMimeType(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PATH)) + { + dataNode.setPath(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PATHPATTERN)) + { + dataNode.setPathPattern(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PATHPREFIX)) + { + dataNode.setPathPrefix(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PORT)) + { + dataNode.setPort(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_SCHEME)) + { + dataNode.setScheme(attrValue); + } + else + { + dataNode.addUnknownProperty(attrName, attrValue); + } + } + + return dataNode; + } + + /** + * Parses a <metadata> node + * + * @param attributes The node attributes + * @return a MetadataNode object corresponding to the node + */ + protected MetadataNode parseMetadataNode(NamedNodeMap attributes) + { + MetadataNode metadataNode = new MetadataNode(""); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_NAME)) + { + metadataNode.setName(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_RESOURCE)) + { + metadataNode.setResource(attrValue); + } + else if (attrName.equals(PROP_VALUE)) + { + metadataNode.setValue(attrValue); + } + else + { + metadataNode.addUnknownProperty(attrName, attrValue); + } + } + + return metadataNode; + } + + /** + * Parses an <activity-alias> node + * + * @param attributes The node attributes + * @return an ActivityNode object corresponding to the node + */ + protected ActivityAliasNode parseActivityAliasNode(NamedNodeMap attributes) + { + ActivityAliasNode activityAliasNode = new ActivityAliasNode("", ""); + String attrName, attrValue; + + parseAbstractIconLabelNameNode(attributes, activityAliasNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ENABLED)) + { + Boolean enabled = Boolean.parseBoolean(attrValue); + activityAliasNode.setEnabled(enabled); + } + else if (attrName.equalsIgnoreCase(PROP_EXPORTED)) + { + Boolean exported = Boolean.parseBoolean(attrValue); + activityAliasNode.setExported(exported); + } + else if (attrName.equalsIgnoreCase(PROP_PERMISSION)) + { + activityAliasNode.setPermission(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_TARGETACTIVITY)) + { + activityAliasNode.setTargetActivity(attrValue); + } + else + { + activityAliasNode.addUnknownProperty(attrName, attrValue); + } + } + + return activityAliasNode; + } + + /** + * Parses a <service> node + * + * @param attributes The node attributes + * @return a ServiceNode object corresponding to the node + */ + protected ServiceNode parseServiceNode(NamedNodeMap attributes) + { + ServiceNode serviceNode = new ServiceNode(""); + String attrName, attrValue; + + parseAbstractBuildingBlockNode(attributes, serviceNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + serviceNode.addUnknownProperty(attrName, attrValue); + } + + return serviceNode; + } + + /** + * Parses a <receiver> node + * + * @param attributes The node attributes + * @return a ReceiverNode object corresponding to the node + */ + protected ReceiverNode parseReceiverNode(NamedNodeMap attributes) + { + ReceiverNode receiverNode = new ReceiverNode(""); + String attrName, attrValue; + + parseAbstractBuildingBlockNode(attributes, receiverNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + receiverNode.addUnknownProperty(attrName, attrValue); + } + + return receiverNode; + } + + /** + * Parses a <provider> node + * + * @param attributes The node attributes + * @return a ProviderNode object corresponding to the node + */ + protected ProviderNode parseProviderNode(NamedNodeMap attributes) + { + ProviderNode providerNode = new ProviderNode("", ""); + String attrName, attrValue; + + parseAbstractBuildingBlockNode(attributes, providerNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_AUTHORITIES)) + { + String[] authorities = attrValue.split(";"); + + for (String authority : authorities) + { + providerNode.addAuthority(authority); + } + + providerNode.removeAuthority(""); + } + else if (attrName.equalsIgnoreCase(PROP_GRANTURIPERMISSIONS)) + { + Boolean grantUriPermissions = Boolean.parseBoolean(attrValue); + providerNode.setGrantUriPermissions(grantUriPermissions); + } + else if (attrName.equalsIgnoreCase(PROP_INITORDER)) + { + try + { + Integer initOrder = Integer.parseInt(attrValue); + providerNode.setInitOrder(initOrder); + } + catch (NumberFormatException nfe) + { + String errMsg = + NLS.bind( + UtilitiesNLS.ERR_AndroidManifestNodeParser_ErrorParsingInitOrder, + attrValue); + parseErrors.add(errMsg); + StudioLogger.error(AndroidManifestNodeParser.class, errMsg, nfe); + } + } + else if (attrName.equalsIgnoreCase(PROP_MULTIPROCESS)) + { + Boolean multiprocess = Boolean.parseBoolean(attrValue); + providerNode.setMultiprocess(multiprocess); + } + else if (attrName.equalsIgnoreCase(PROP_READPERMISSION)) + { + providerNode.setReadPermission(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_SYNCABLE)) + { + Boolean syncable = Boolean.parseBoolean(attrValue); + providerNode.setSyncable(syncable); + } + else if (attrName.equalsIgnoreCase(PROP_WRITEPERMISSION)) + { + providerNode.setWritePermission(attrValue); + } + else + { + providerNode.addUnknownProperty(attrName, attrValue); + } + } + + return providerNode; + } + + /** + * Parses a <grant-uri-permission> node + * + * @param attributes The node attributes + * @return a GrantUriPermissionNode object corresponding to the node + */ + protected GrantUriPermissionNode parseGrantUriPermissionNode(NamedNodeMap attributes) + { + GrantUriPermissionNode grantUriPermissionNode = new GrantUriPermissionNode(); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_PATH)) + { + grantUriPermissionNode.setPath(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PATHPATTERN)) + { + grantUriPermissionNode.setPathPattern(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PATHPREFIX)) + { + grantUriPermissionNode.setPathPrefix(attrValue); + } + else + { + grantUriPermissionNode.addUnknownProperty(attrName, attrValue); + } + } + + return grantUriPermissionNode; + } + + /** + * Parses an <uses-library> node + * + * @param attributes The node attributes + * @return an UsesLibraryNode object corresponding to the node + */ + protected UsesLibraryNode parseUsesLibraryNode(NamedNodeMap attributes) + { + UsesLibraryNode usesLibraryNode = new UsesLibraryNode(""); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_NAME)) + { + usesLibraryNode.setName(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_REQUIRED)) + { + usesLibraryNode.setRequired(Boolean.parseBoolean(attrValue)); + } + else + { + usesLibraryNode.addUnknownProperty(attrName, attrValue); + } + } + + return usesLibraryNode; + } + + /** + * Parses an <uses-feature> node + * + * @param attributes The node attributes + * @return an UsesFeatureNode object corresponding to the node + */ + protected UsesFeatureNode parseUsesFeatureNode(NamedNodeMap attributes) + { + UsesFeatureNode usesFeatureNode = new UsesFeatureNode(""); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_NAME)) + { + usesFeatureNode.setName(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_REQUIRED)) + { + usesFeatureNode.setRequired(Boolean.parseBoolean(attrValue)); + } + else + { + usesFeatureNode.addUnknownProperty(attrName, attrValue); + } + } + + return usesFeatureNode; + } + + /** + * Parses a comment node (<!-- This is a comment -->) + * + * @param comment The xml comment node + * + * @return a CommentNode object representing the xml comment node + */ + protected CommentNode parseCommentNode(Comment comment) + { + CommentNode commentNode = new CommentNode(); + commentNode.setComment(comment.getTextContent()); + + return commentNode; + } + + /** + * Creates an unknown node based on its attributes. An node is classified as + * unknown when it is not specified by the AndroidManifest.xml file specification + * or when it is under another node that could not contain it. + * + * @param attributes The node attributes + * @return a UnknownNode object corresponding to the node + */ + protected UnknownNode parseUnknownNode(String nodeName, NamedNodeMap attributes) + { + UnknownNode unknownNode = new UnknownNode(nodeName); + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + unknownNode.addUnknownProperty(attrName, attrValue); + } + + return unknownNode; + } + + /** + * Sets all attributes relative to an AbstractIconLabelNameNode from an + * attributes list + * + * @param attributes The node attributes + * @param amNode The AbstractIconLabelNameNode where the attributes must be in + */ + private void parseAbstractIconLabelNameNode(NamedNodeMap attributes, + AbstractIconLabelNameNode amNode) + { + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ICON)) + { + amNode.setIcon(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_LABEL)) + { + amNode.setLabel(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_NAME)) + { + amNode.setName(attrValue); + } + } + } + + /** + * Sets all attributes relative to an AbstractBuildingBlockNode from an + * attributes list + * + * @param attributes The node attributes + * @param amNode The AbstractBuildingBlockNode where the attributes must be in + */ + private void parseAbstractBuildingBlockNode(NamedNodeMap attributes, + AbstractBuildingBlockNode amNode) + { + String attrName, attrValue; + Boolean boolValue; + + parseAbstractIconLabelNameNode(attributes, amNode); + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_ENABLED)) + { + boolValue = Boolean.parseBoolean(attrValue); + amNode.setEnabled(boolValue); + } + else if (attrName.equalsIgnoreCase(PROP_EXPORTED)) + { + boolValue = Boolean.parseBoolean(attrValue); + amNode.setExported(boolValue); + } + else if (attrName.equalsIgnoreCase(PROP_PERMISSION)) + { + amNode.setPermission(attrValue); + } + else if (attrName.equalsIgnoreCase(PROP_PROCESS)) + { + amNode.setProcess(attrValue); + } + } + } + + /** + * Sets all attributes relative to an AbstractSimpleNameNode from an + * attributes list + * + * @param attributes The node attributes + * @param amNode The AbstractSimpleNameNode where the attributes must be in + */ + private void parseAbstractSimpleNameNode(NamedNodeMap attributes, AbstractSimpleNameNode amNode) + { + String attrName, attrValue; + + for (int i = 0; i < attributes.getLength(); i++) + { + attrName = attributes.item(i).getNodeName().trim(); + attrValue = attributes.item(i).getNodeValue(); + + if (attrName.equalsIgnoreCase(PROP_NAME)) + { + amNode.setName(attrValue); + } + } + } +} |