path: root/src/plugins/common/src/com/motorola/studio/android/model/manifest/parser/AndroidManifestNodeParser.java

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