/*
* 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);
}
}
}
}