/*
* 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.motorolamobility.preflighting.checkers.deviceCompatibility;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.IStatus;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.motorolamobility.preflighting.checkers.CheckerPlugin;
import com.motorolamobility.preflighting.checkers.i18n.CheckerNLS;
import com.motorolamobility.preflighting.core.applicationdata.ApplicationData;
import com.motorolamobility.preflighting.core.applicationdata.XMLElement;
import com.motorolamobility.preflighting.core.checker.condition.CanExecuteConditionStatus;
import com.motorolamobility.preflighting.core.checker.condition.Condition;
import com.motorolamobility.preflighting.core.checker.condition.ICondition;
import com.motorolamobility.preflighting.core.devicelayoutspecification.Device;
import com.motorolamobility.preflighting.core.devicespecification.DeviceSpecification;
import com.motorolamobility.preflighting.core.devicespecification.internal.PlatformRules;
import com.motorolamobility.preflighting.core.exception.PreflightingCheckerException;
import com.motorolamobility.preflighting.core.internal.cond.utils.ConditionUtils;
import com.motorolamobility.preflighting.core.permissionfeature.Feature;
import com.motorolamobility.preflighting.core.utils.XmlUtils;
import com.motorolamobility.preflighting.core.validation.ValidationManagerConfiguration;
import com.motorolamobility.preflighting.core.validation.ValidationResult;
import com.motorolamobility.preflighting.core.validation.ValidationResultData;
/**
* Check if application requires any feature that is not available on a given device.
*/
public class UnsupportedFeaturesConditions extends Condition implements ICondition
{
private static final String USES_FEATURE = "uses-feature"; //$NON-NLS-1$
private static final String USES_PERMISSION = "uses-permission"; //$NON-NLS-1$
private static final String ANDROID_NAME = "android:name"; //$NON-NLS-1$
private static final String ANDROID_REQUIRED = "android:required"; //$NON-NLS-1$
/**
* Elements to validate
*/
private XMLElement manifestElement;
@Override
public CanExecuteConditionStatus canExecute(ApplicationData data,
List<DeviceSpecification> deviceSpecs) throws PreflightingCheckerException
{
CanExecuteConditionStatus status =
new CanExecuteConditionStatus(IStatus.OK, CheckerPlugin.PLUGIN_ID, "");
manifestElement = data.getManifestElement();
if (manifestElement == null)
{
status =
new CanExecuteConditionStatus(IStatus.ERROR, CheckerPlugin.PLUGIN_ID,
CheckerNLS.Invalid_ManifestFile);
}
else
{
Document manifestDoc = manifestElement.getDocument();
if (manifestDoc == null)
{
status =
new CanExecuteConditionStatus(IStatus.ERROR, CheckerPlugin.PLUGIN_ID,
CheckerNLS.Invalid_ManifestFile);
}
}
status.setConditionId(getId());
return status;
}
@Override
public void execute(ApplicationData data, List<DeviceSpecification> deviceSpecs,
ValidationManagerConfiguration valManagerConfig, ValidationResult results)
throws PreflightingCheckerException
{
checkUnsupportedFeatures(PlatformRules.getInstance(), deviceSpecs, valManagerConfig,
results);
}
/**
* Check if there is features (declared or implied) that are unsupported by a device
* @param platformRules
* @param deviceSpecs
* @param valManagerConfig
* @param resultList
* @throws PreflightingCheckerException
*/
private void checkUnsupportedFeatures(PlatformRules platformRules,
List<DeviceSpecification> deviceSpecs, ValidationManagerConfiguration valManagerConfig,
ValidationResult results) throws PreflightingCheckerException
{
Document manifestDoc = manifestElement.getDocument();
//collecting set of declared features
Map<String, Feature> featuresDeclared = new HashMap<String, Feature>();
for (DeviceSpecification deviceSpec : deviceSpecs)
{
Device device = deviceSpec.getDeviceInfo();
checkIssuesForDeclaredFeatures(valManagerConfig, results, manifestDoc,
featuresDeclared, device);
checkIssuesForFeaturesImplied(platformRules, valManagerConfig, results, manifestDoc,
featuresDeclared, device);
}
}
/**
* Checks unsupported features for a device that were declared
* @param platformRules
* @param valManagerConfig
* @param resultList
* @param manifestDoc
* @param featuresDeclared
* @param device
* @throws PreflightingCheckerException
*/
private void checkIssuesForFeaturesImplied(PlatformRules platformRules,
ValidationManagerConfiguration valManagerConfig, ValidationResult results,
Document manifestDoc, Map<String, Feature> featuresDeclared, Device device)
throws PreflightingCheckerException
{
int currentIssuedLine;
String preview;
//collecting set of declared features derived from permissions
NodeList permissionsLst = manifestDoc.getElementsByTagName(USES_PERMISSION);
for (int i = 0; i < permissionsLst.getLength(); i++)
{
Node permissionNode = permissionsLst.item(i);
NamedNodeMap permissionMap = permissionNode.getAttributes();
Node permissionAtr = permissionMap.getNamedItem(ANDROID_NAME); //$NON-NLS-1$
Node permissionRequiredAtr = permissionMap.getNamedItem(ANDROID_REQUIRED);//$NON-NLS-1$
try
{
boolean required = true;
if (permissionRequiredAtr != null)
{
required = permissionRequiredAtr.getNodeValue().trim().equals("true"); //$NON-NLS-1$
}
if (required && (permissionAtr != null)
&& !permissionAtr.getNodeValue().trim().equals("")) //$NON-NLS-1$
{
String permissionId = permissionAtr.getNodeValue();
Set<Feature> featuresImplied =
platformRules.getImpliedFeaturesSet(permissionId);
for (Feature impliedFeature : featuresImplied)
{
if (!device.getSupportedFeatures().isEmpty()
&& !device.getSupportedFeatures().contains(impliedFeature))
{
//if device has features supported declared (old devices.xml won't have this declaration)
//and feature was not found
Feature decl = featuresDeclared.get(impliedFeature.getId());
if ((decl == null) || decl.isRequired())
{
//permission => implied feature unsupported : raise issue
//because it is not marked as not required
currentIssuedLine =
manifestElement.getNodeLineNumber(permissionNode);
preview = XmlUtils.getXMLNodeAsString(permissionNode, false);
//feature declared but unsupported => raise warning
ValidationResultData resultData = new ValidationResultData();
resultData.setSeverity(getSeverityLevel());
resultData.setConditionID(getId());
resultData
.setIssueDescription(CheckerNLS
.bind(CheckerNLS.DeviceCompatibilityChecker_CONDITION_UNSUPPORTED_FEATURE_IMPLIED_ISSUE_DESCRIPTION,
new String[]
{
permissionId,
impliedFeature.getId(),
device.getName()
}));
String fixSuggestionMessage =
(CheckerNLS
.bind(CheckerNLS.DeviceCompatibilityChecker_CONDITION_UNSUPPORTED_FEATURE_FIX_SUGGESTION,
new String[]
{
impliedFeature.getId()
}));
resultData.setQuickFixSuggestion(fixSuggestionMessage);
resultData.setMarkerType(getMarkerType());
resultData.appendExtra(impliedFeature.getId());
ArrayList<Integer> lines = new ArrayList<Integer>();
lines.add(currentIssuedLine);
resultData.addFileToIssueLines(manifestElement.getFile(), lines);
resultData.setInfoURL(ConditionUtils.getDescriptionLink(
getChecker().getId(), getId(), valManagerConfig));
resultData.setPreview(preview);
results.addValidationResult(resultData);
}
}
}
}
}
catch (DOMException e)
{
// Error retrieving attribute
throw new PreflightingCheckerException(
CheckerNLS.bind(
CheckerNLS.AndroidMarketFiltersChecker_Exception_Getting_Manifest_Attribute,
ANDROID_NAME), e);
}
}
}
/**
* Checks unsupported features for a device (permissions that imply in features)
* @param valManagerConfig
* @param resultList
* @param manifestDoc
* @param featuresDeclared
* @param device
*/
private void checkIssuesForDeclaredFeatures(ValidationManagerConfiguration valManagerConfig,
ValidationResult results, Document manifestDoc, Map<String, Feature> featuresDeclared,
Device device)
{
int currentIssuedLine;
String preview;
NodeList featureLst = manifestDoc.getElementsByTagName(USES_FEATURE);
for (int j = 0; j < featureLst.getLength(); j++)
{
Node featureNode = featureLst.item(j);
NamedNodeMap featureMap = featureNode.getAttributes();
Node featureAtr = featureMap.getNamedItem(ANDROID_NAME);
Node featureRequiredAtr = featureMap.getNamedItem(ANDROID_REQUIRED);//$NON-NLS-1$
if ((featureAtr != null) && !featureAtr.getNodeValue().trim().equals("")) //$NON-NLS-1$
{
Feature featDecl = new Feature(featureAtr.getNodeValue());
boolean required = true;
if (featureRequiredAtr != null)
{
required = featureRequiredAtr.getNodeValue().trim().equals("true"); //$NON-NLS-1$
featDecl.setRequired(required);
}
featuresDeclared.put(featDecl.getId(), featDecl);
if (required)
{
if (!device.getSupportedFeatures().isEmpty()
&& !device.getSupportedFeatures().contains(featDecl))
{
//if device has features supported declared (old devices.xml won't have this declaration)
//and feature was not found
//feature declared but unsupported => raise issue
currentIssuedLine = manifestElement.getNodeLineNumber(featureNode);
preview = XmlUtils.getXMLNodeAsString(featureNode, false);
ValidationResultData resultData = new ValidationResultData();
resultData.setSeverity(getSeverityLevel());
resultData.setConditionID(getId());
resultData
.setIssueDescription(CheckerNLS
.bind(CheckerNLS.DeviceCompatibilityChecker_CONDITION_UNSUPPORTED_FEATURE_DECLARED_ISSUE_DESCRIPTION,
new String[]
{
featDecl.getId(), device.getName()
}));
String fixSuggestionMessage =
(CheckerNLS
.bind(CheckerNLS.DeviceCompatibilityChecker_CONDITION_UNSUPPORTED_FEATURE_FIX_SUGGESTION,
new String[]
{
featDecl.getId()
}));
resultData.setQuickFixSuggestion(fixSuggestionMessage);
resultData.setMarkerType(getMarkerType());
resultData.appendExtra(featDecl.getId());
ArrayList<Integer> lines = new ArrayList<Integer>();
lines.add(currentIssuedLine);
resultData.addFileToIssueLines(manifestElement.getFile(), lines);
resultData.setInfoURL(ConditionUtils.getDescriptionLink(getChecker()
.getId(), getId(), valManagerConfig));
resultData.setPreview(preview);
results.addValidationResult(resultData);
}
}
}
}
}
}