diff options
Diffstat (limited to 'src/plugins/common/src/com/motorola/studio/android/model/manifest/dom/ActivityNode.java')
| -rw-r--r-- | src/plugins/common/src/com/motorola/studio/android/model/manifest/dom/ActivityNode.java | 882 |
1 files changed, 882 insertions, 0 deletions
diff --git a/src/plugins/common/src/com/motorola/studio/android/model/manifest/dom/ActivityNode.java b/src/plugins/common/src/com/motorola/studio/android/model/manifest/dom/ActivityNode.java new file mode 100644 index 0000000..c410067 --- /dev/null +++ b/src/plugins/common/src/com/motorola/studio/android/model/manifest/dom/ActivityNode.java @@ -0,0 +1,882 @@ +/* +* 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.dom; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.eclipse.core.runtime.IStatus; + +import com.motorola.studio.android.common.IAndroidConstants; + +/** + * Class that represents an <activity> node on AndroidManifest.xml file + */ +public class ActivityNode extends AbstractBuildingBlockNode +{ + static + { + defaultProperties.add(PROP_ALLOWTASKREPARENTING); + defaultProperties.add(PROP_ALWAYSRETAINTASKSTATE); + defaultProperties.add(PROP_CLEARTASKONLAUNCH); + defaultProperties.add(PROP_CONFIGCHANGES); + defaultProperties.add(PROP_EXCLUDEFROMRECENTS); + defaultProperties.add(PROP_FINISHONTASKLAUNCH); + defaultProperties.add(PROP_LAUNCHMODE); + defaultProperties.add(PROP_MULTIPROCESS); + defaultProperties.add(PROP_SCREENORIENTATION); + defaultProperties.add(PROP_STATENOTNEEDED); + defaultProperties.add(PROP_TASKAFFINITY); + defaultProperties.add(PROP_THEME); + } + + /** + * Enumeration for configChanges property + */ + public static enum ConfigChanges + { + mcc, mnc, locale, touchscreen, keyboard, keyboardHidden, navigation, orientation, fontscale + } + + /** + * Enumeration for launchMode property + */ + public static enum LaunchMode + { + standard, singleTop, singleTask, singleInstance + } + + /** + * Enumeration for screenOrientation property + */ + public static enum ScreenOrientation + { + unspecified, user, behind, landscape, portrait, sensor, nonsensor + } + + /** + * Map to resolve the string<->enumeration association of configChanges property + */ + private static Map<String, ConfigChanges> configChanges; + + /** + * Map to resolve the string<->enumeration association of launchMode property + */ + private static Map<String, LaunchMode> launchModes; + + /** + * Map to resolve the string<->enumeration association of screenOrientation property + */ + private static Map<String, ScreenOrientation> screenOrientations; + + static + { + configChanges = new HashMap<String, ConfigChanges>(); + + // Loads the map for configChanges + for (ConfigChanges configChange : ConfigChanges.values()) + { + configChanges.put(configChange.toString().toLowerCase(), configChange); + } + + launchModes = new HashMap<String, LaunchMode>(); + + // Loads the map for launchMode + for (LaunchMode launchMode : LaunchMode.values()) + { + launchModes.put(launchMode.toString().toLowerCase(), launchMode); + } + + screenOrientations = new HashMap<String, ScreenOrientation>(); + + // Loads the map for screenOrientation + for (ScreenOrientation screenOrientation : ScreenOrientation.values()) + { + screenOrientations.put(screenOrientation.toString().toLowerCase(), screenOrientation); + } + } + + /** + * Gets the configChange parameter name from a given ConfigChanges enumeration value + * + * @param configChange the enumeration value + * @return the configChange parameter name + */ + public static String getConfigChangeName(ConfigChanges configChange) + { + String name = ""; + + if (configChange != null) + { + name = configChange.toString(); + } + + return name; + } + + /** + * Gets the enumeration value of the ConfigChanges enumeration from a given name + * + * @param configChangeName the configChanges name + * @return the enumeration value of the ConfigChanges enumeration + */ + public static ConfigChanges getConfigChangeFromName(String configChangeName) + { + ConfigChanges configChange = null; + + if (configChangeName != null) + { + String ccn = configChangeName.trim().toLowerCase(); + configChange = configChanges.get(ccn); + } + + return configChange; + } + + /** + * Gets the launchMode parameter name from a given LaunchMode enumeration value + * + * @param launchMode the enumeration value + * @return the LaunchMode parameter name + */ + public static String getLaunchModeName(LaunchMode launchMode) + { + String name = ""; + + if (launchMode != null) + { + name = launchMode.toString(); + } + + return name; + } + + /** + * Gets the enumeration value of the LaunchMode enumeration from a given name + * + * @param launchModeName the launchMode name + * @return the enumeration value of the LaunchMode enumeration + */ + public static LaunchMode getLaunchModeFromName(String launchModeName) + { + LaunchMode launchMode = null; + + if (launchModeName != null) + { + String lmn = launchModeName.trim().toLowerCase(); + launchMode = launchModes.get(lmn); + } + + return launchMode; + } + + /** + * Gets the screenOrientation parameter name from a given ScreenOrientation enumeration value + * + * @param screenOrientation the enumeration value + * @return the ScreenOrientation parameter name + */ + public static String getScreenOrientationName(ScreenOrientation screenOrientation) + { + String name = ""; + + if (screenOrientation != null) + { + name = screenOrientation.toString(); + } + + return name; + } + + /** + * Gets the enumeration value of the ScreenOrientation enumeration from a given name + * + * @param screenOrientationName the screenOrientation name + * @return the enumeration value of the ScreenOrientation enumeration + */ + public static ScreenOrientation getScreenOrientationFromName(String screenOrientationName) + { + ScreenOrientation screenOrientation = null; + + if (screenOrientationName != null) + { + String son = screenOrientationName.trim().toLowerCase(); + screenOrientation = screenOrientations.get(son); + } + + return screenOrientation; + } + + /** + * The allowTaskReparenting property + */ + private Boolean propAllowTaskReparenting = null; + + /** + * The alwaysRetainTaskState property + */ + private Boolean propAlwaysRetainTaskState = null; + + /** + * The clearTaskOnLaunch property + */ + private Boolean propClearTaskOnLaunch = null; + + /** + * The configChanges property (can hold more than one value) + */ + private final List<ConfigChanges> propConfigChanges = new LinkedList<ConfigChanges>(); + + /** + * The excludeFromRecents property + */ + private Boolean propExcludeFromRecents = null; + + /** + * The finishOnTaskLaunch property + */ + private Boolean propFinishOnTaskLaunch = null; + + /** + * The launchMode property + */ + private LaunchMode propLaunchMode = null; + + /** + * The multiProcess property + */ + private Boolean propMultiprocess = null; + + /** + * The screenOrientation property + */ + private ScreenOrientation propScreenOrientation = null; + + /** + * The stateNotNeeded property + */ + private Boolean propStateNotNeeded = null; + + /** + * The taskAffinity property + */ + private String propTaskAffinity = null; + + /** + * The theme property + */ + private String propTheme = null; + + /** + * Default constructor + * + * @param name The name property. It must not be null. + */ + public ActivityNode(String name) + { + super(name); + } + + /* (non-Javadoc) + * @see com.motorola.studio.android.model.manifest.dom.AndroidManifestNode#canContains(com.motorola.studio.android.model.manifest.dom.AndroidManifestNode.NodeType) + */ + @Override + protected boolean canContains(NodeType nodeType) + { + return (nodeType == NodeType.IntentFilter) || (nodeType == NodeType.MetaData) + || (nodeType == NodeType.Comment); + } + + /* (non-Javadoc) + * @see com.motorola.studio.android.model.manifest.dom.AbstractIconLabelNameNode#addAdditionalProperties() + */ + @Override + protected void addAdditionalProperties() + { + super.addAdditionalProperties(); + + if (propAllowTaskReparenting != null) + { + properties.put(PROP_ALLOWTASKREPARENTING, propAllowTaskReparenting.toString()); + } + + if (propAlwaysRetainTaskState != null) + { + properties.put(PROP_ALWAYSRETAINTASKSTATE, propAlwaysRetainTaskState.toString()); + } + + if (propClearTaskOnLaunch != null) + { + properties.put(PROP_CLEARTASKONLAUNCH, propClearTaskOnLaunch.toString()); + } + + if ((propConfigChanges != null) && !propConfigChanges.isEmpty()) + { + String configChangesString = ""; + + for (int i = 0; i < (propConfigChanges.size() - 1); i++) + { + configChangesString += getConfigChangeName(propConfigChanges.get(i)) + "|"; + } + + configChangesString += + getConfigChangeName(propConfigChanges.get(propConfigChanges.size() - 1)); + + properties.put(PROP_CONFIGCHANGES, configChangesString); + } + + if (propExcludeFromRecents != null) + { + properties.put(PROP_EXCLUDEFROMRECENTS, propExcludeFromRecents.toString()); + } + + if (propFinishOnTaskLaunch != null) + { + properties.put(PROP_FINISHONTASKLAUNCH, propFinishOnTaskLaunch.toString()); + } + + if (propLaunchMode != null) + { + properties.put(PROP_LAUNCHMODE, getLaunchModeName(propLaunchMode)); + } + + if (propMultiprocess != null) + { + properties.put(PROP_MULTIPROCESS, propMultiprocess.toString()); + } + + if (propScreenOrientation != null) + { + properties.put(PROP_SCREENORIENTATION, getScreenOrientationName(propScreenOrientation)); + } + + if (propStateNotNeeded != null) + { + properties.put(PROP_STATENOTNEEDED, propStateNotNeeded.toString()); + } + + if (propTaskAffinity != null) + { + properties.put(PROP_TASKAFFINITY, propTaskAffinity); + } + + if (propTheme != null) + { + properties.put(PROP_THEME, propTheme); + } + } + + /* (non-Javadoc) + * @see com.motorola.studio.android.model.manifest.dom.AndroidManifestNode#getNodeType() + */ + @Override + public NodeType getNodeType() + { + return NodeType.Activity; + } + + /* (non-Javadoc) + * @see com.motorola.studio.android.model.manifest.dom.AndroidManifestNode#isNodeValid() + */ + @Override + protected boolean isNodeValid() + { + return super.isNodeValid(); + } + + /** + * Gets the allowTaskReparenting property value + * + * @return the allowTaskReparenting property value + */ + public Boolean getAllowTaskReparenting() + { + return propAllowTaskReparenting; + } + + /** + * Sets the allowTaskReparenting property value. Set it to null to remove it. + * + * @param allowTaskReparenting the allowTaskReparenting property value + */ + public void setAllowTaskReparenting(Boolean allowTaskReparenting) + { + this.propAllowTaskReparenting = allowTaskReparenting; + } + + /** + * Gets the alwaysRetainTaskState property value + * + * @return the alwaysRetainTaskState property value + */ + public Boolean getAlwaysRetainTaskState() + { + return propAlwaysRetainTaskState; + } + + /** + * Sets the alwaysRetainTaskState property value. Set it to null to remove it. + * + * @param alwaysRetainTaskState the alwaysRetainTaskState property value + */ + public void setAlwaysRetainTaskState(Boolean alwaysRetainTaskState) + { + this.propAlwaysRetainTaskState = alwaysRetainTaskState; + } + + /** + * Gets the clearTaskOnLaunch property value + * + * @return the clearTaskOnLaunch property value + */ + public Boolean getClearTaskOnLaunch() + { + return propClearTaskOnLaunch; + } + + /** + * Sets the clearTaskOnLaunch property value. Set it to null to remove it. + * + * @param clearTaskOnLaunch the clearTaskOnLaunch property value + */ + public void setClearTaskOnLaunch(Boolean clearTaskOnLaunch) + { + this.propClearTaskOnLaunch = clearTaskOnLaunch; + } + + /** + * Gets the configChanges property value as an array + * + * @return the configChanges property value as an array + */ + public ConfigChanges[] getConfigChanges() + { + ConfigChanges[] configChanges = null; + + if (propConfigChanges != null) + { + configChanges = new ConfigChanges[propConfigChanges.size()]; + configChanges = propConfigChanges.toArray(configChanges); + } + + return configChanges; + } + + /** + * Adds a new config change to the configChanges property + * + * @param configChanges the new config change to be added + */ + public void addConfigChanges(ConfigChanges configChanges) + { + if (configChanges != null) + { + if (!propConfigChanges.contains(configChanges)) + { + propConfigChanges.add(configChanges); + } + } + } + + /** + * Gets the excludeFromRecents property value + * + * @return the excludeFromRecents property value + */ + public Boolean getExcludeFromRecents() + { + return propExcludeFromRecents; + } + + /** + * Sets the excludeFromRecents property value. Set it to null to remove it. + * + * @param excludeFromRecents the excludeFromRecents property value + */ + public void setExcludeFromRecents(Boolean excludeFromRecents) + { + this.propExcludeFromRecents = excludeFromRecents; + } + + /** + * Gets the finishOnTaskLaunch property value + * + * @return the finishOnTaskLaunch property value + */ + public Boolean getFinishOnTaskLaunch() + { + return propFinishOnTaskLaunch; + } + + /** + * Sets the finishOnTaskLaunch property value. Set it to null to remove it. + * + * @param finishOnTaskLaunch the finishOnTaskLaunch property value + */ + public void setFinishOnTaskLaunch(Boolean finishOnTaskLaunch) + { + this.propFinishOnTaskLaunch = finishOnTaskLaunch; + } + + /** + * Gets the launchMode property value + * + * @return the launchMode property value + */ + public LaunchMode getLaunchMode() + { + return propLaunchMode; + } + + /** + * Sets the launchMode property value. Set it to null to remove it. + * + * @param launchMode the launchMode property value + */ + public void setLaunchMode(LaunchMode launchMode) + { + this.propLaunchMode = launchMode; + } + + /** + * Gets the multiProcess property value + * + * @return the multiProcess property value + */ + public Boolean getMultiprocess() + { + return propMultiprocess; + } + + /** + * Sets the multiProcess property value. Set it to null to remove it. + * + * @param multiProcess the multiProcess property value + */ + public void setMultiprocess(Boolean multiProcess) + { + this.propMultiprocess = multiProcess; + } + + /** + * Gets the screenOrientation property value + * + * @return the screenOrientation property value + */ + public ScreenOrientation getScreenOrientation() + { + return propScreenOrientation; + } + + /** + * Sets the screenOrientation property value. Set it to null to remove it. + * + * @param screenOrientation the screenOrientation property value + */ + public void setScreenOrientation(ScreenOrientation screenOrientation) + { + this.propScreenOrientation = screenOrientation; + } + + /** + * Gets the stateNotNeeded property value + * + * @return the stateNotNeeded property value + */ + public Boolean getStateNotNeeded() + { + return propStateNotNeeded; + } + + /** + * Sets the stateNotNeeded property value. Set it to null to remove it. + * + * @param stateNotNeeded the stateNotNeeded property value + */ + public void setStateNotNeeded(Boolean stateNotNeeded) + { + this.propStateNotNeeded = stateNotNeeded; + } + + /** + * Gets the taskAffinity property value + * + * @return the taskAffinity property value + */ + public String getTaskAffinity() + { + return propTaskAffinity; + } + + /** + * Sets the taskAffinity property value. Set it to null to remove it. + * + * @param taskAffinity the taskAffinity property value + */ + public void setTaskAffinity(String taskAffinity) + { + this.propTaskAffinity = taskAffinity; + } + + /** + * Gets the theme property value + * + * @return the theme property value + */ + public String getTheme() + { + return propTheme; + } + + /** + * Sets the theme property value. Set it to null to remove it. + * + * @param theme the theme property value + */ + public void setTheme(String theme) + { + this.propTheme = theme; + } + + /** + * Adds an Intent Filter Node to the Activity Node + * + * @param intentFilter The Intent Filter Node + */ + public void addIntentFilterNode(IntentFilterNode intentFilter) + { + if (intentFilter != null) + { + if (!children.contains(intentFilter)) + { + children.add(intentFilter); + } + } + } + + /** + * Retrieves all Intent Filter Nodes from the Activity Node + * + * @return all Intent Filter Nodes from the Activity Node + */ + public List<IntentFilterNode> getIntentFilterNodes() + { + List<IntentFilterNode> intentFilters = new LinkedList<IntentFilterNode>(); + + for (AndroidManifestNode node : getAllChildrenFromType(NodeType.IntentFilter)) + { + intentFilters.add((IntentFilterNode) node); + } + + return intentFilters; + } + + /** + * Removes an Intent Filter Node from the Activity Node + * + * @param intentFilter the Intent Filter Node to be removed + */ + public void removeIntentFilterNode(IntentFilterNode intentFilter) + { + if (intentFilter != null) + { + children.remove(intentFilter); + } + } + + /** + * If parameter {@code isMainActivity} is true, then the intent-filters that represent main activities are added to this activity. + * If parameter {@code isMainActivity} is false, then the intent-filters that represent main activities are removed from this activity. + * @param isMainActivity True is this activity should be set as the main activity. False if the activity should not be set as the main activity. + * @return True if the operation requested was successfully performed. False otherwise. Possible scenarios are: + * This activity is the main activity and {@code isMainActivity} is true. In this case, this method returns true. + * This activity is the main activity and {@code isMainActivity} is false. In this case, this method returns true if the intent-filters were successfully removed from this activity node, false otherwise. + * This activity is not the main activity and {@code isMainActivity} is true. In this case, this method returns true if the required intent-filters were successfully added to this activity node, false otherwise. + * This activity is not the main activity and {@code isMainActivity} is false. In this case, this method returns true. + * */ + public boolean setAsMainActivity(boolean isMainActivity) + { + boolean result = false; + + // check if this this activity should be a main activity or not + if (isMainActivity) + { + // set this activity to be a main activity + if (this.isMainActivity()) + { + // this already is a main activity + result = true; + } + else + { + // set as main activity + IntentFilterNode intentFilterNode = new IntentFilterNode(); + ActionNode actionMainNode = new ActionNode(IAndroidConstants.ACTION_MAIN); + CategoryNode categoryLauncherNode = + new CategoryNode(IAndroidConstants.CATEGORY_LAUNCHER); + + intentFilterNode.addActionNode(actionMainNode); + intentFilterNode.addCategoryNode(categoryLauncherNode); + this.addIntentFilterNode(intentFilterNode); + + result = true; + } + } + else + { + // unset this activity as main activity + if (!this.isMainActivity()) + { + //this activity is not a main activity + result = true; + } + else + { + // unset this activity as main activity, i.e., remove action main and category launcher from its intent-filters + for (IntentFilterNode intentFilterNode : getIntentFilterNodes()) + { + ActionNode actionMainNode = + intentFilterNode.getActionNode(IAndroidConstants.ACTION_MAIN); + CategoryNode categoryLauncherNode = + intentFilterNode.getCategoryNode(IAndroidConstants.CATEGORY_LAUNCHER); + + if ((actionMainNode != null) && (categoryLauncherNode != null)) + { + // effectivelly remove the nodes + intentFilterNode.removeActionNode(actionMainNode); + intentFilterNode.removeCategoryNode(categoryLauncherNode); + + if (intentFilterNode.isEmpty()) + { + //also remove the intent-filter node if it was left empty + this.removeIntentFilterNode(intentFilterNode); + } + + result = true; + } + } + } + } + + return result; + } + + /** + * Check if this activity is set as the main activity, i.e., if it has the required intent-filter that represent main activities. + * @return True if this activity is the main activity of the project. False otherwise. + * */ + public boolean isMainActivity() + { + boolean isMainActivity = false; + boolean hasActionMain = false; + boolean hasCategoryLauncher = false; + + //iterate over intent-filter nodes + //looking for action and category nodes that represents main activities + for (IntentFilterNode intent : getIntentFilterNodes()) + { + hasActionMain = false; + hasCategoryLauncher = false; + + //iterate over action nodes + for (ActionNode actionNode : intent.getActionNodes()) + { + if (actionNode.getName().equals(IAndroidConstants.ACTION_MAIN)) + { + //action node for main activities + hasActionMain = true; + break; + } + } + + //iterate over category nodes + for (CategoryNode categoryNode : intent.getCategoryNodes()) + { + if (categoryNode.getName().equals(IAndroidConstants.CATEGORY_LAUNCHER)) + { + //category node for main activities + hasCategoryLauncher = true; + } + } + + //check if the intent-filter has the action and category nodes that represent main activities + if (hasActionMain && hasCategoryLauncher) + { + isMainActivity = true; + break; + } + } + + return isMainActivity; + } + + /** + * Adds a Metadata Node to the Activity Node + * + * @param metadata The Metadata Node + */ + public void addMetadataNode(MetadataNode metadata) + { + if (metadata != null) + { + if (!children.contains(metadata)) + { + children.add(metadata); + } + } + } + + /** + * Retrieves all Metadata Nodes from the Activity Node + * + * @return all Metadata Nodes from the Activity Node + */ + public List<MetadataNode> getMetadataNodes() + { + List<MetadataNode> metadatas = new LinkedList<MetadataNode>(); + + for (AndroidManifestNode node : getAllChildrenFromType(NodeType.MetaData)) + { + metadatas.add((MetadataNode) node); + } + + return metadatas; + } + + /** + * Removes a Metadata Node from the Activity Node + * + * @param metadata the Metadata Node to be removed + */ + public void removeMetadataNode(MetadataNode metadata) + { + if (metadata != null) + { + children.remove(metadata); + } + } + + /* (non-Javadoc) + * @see com.motorola.studio.android.model.manifest.dom.AndroidManifestNode#getSpecificNodeErrors() + */ + @Override + protected List<IStatus> getSpecificNodeProblems() + { + return null; + } +} |