PFW: Parameter adaptation (platform interface)

BZ: 15069

Adaptation nodes have been added to integer parameter types in the structural
description.
They all convert values between a platform value and the actual parameter
value.
When a conversion node affects the definition of an integer type parameter,
its interface type becomes "double" (instead of integer).
For now only linear adaptation type is supported.

Linear adaptation:
=================
Linear adaptation nodes consists of the following attributes:
- slope numerator (double, default = 1)
- slope denominator (double, defult = 1)
- offset (signed integer, default = 0)
Conversions from user (platform) values to blackboard are done the follwing
way:
blackboard_value = user_value * slope_numerator / slope_denominator + offset

Change-Id: I00abe9ba5961d8e541b616225531bbc7c8b465b0
Signed-off-by: Patrick Benavoli <patrickx.benavoli@intel.com>
Reviewed-on: http://android.intel.com:8080/25407
Reviewed-by: Barthes, FabienX <fabienx.barthes@intel.com>
Tested-by: Barthes, FabienX <fabienx.barthes@intel.com>
Reviewed-by: buildbot <buildbot@intel.com>
Tested-by: buildbot <buildbot@intel.com>

1 files changed, 99 insertions, 0 deletions

diff --git a/parameter/IntegerParameterType.cpp b/parameter/IntegerParameterType.cpp
index 71941c2..fb55f08 100644
--- a/parameter/IntegerParameterType.cpp
+++ b/parameter/IntegerParameterType.cpp
@@ -34,6 +34,7 @@
 #include <iomanip>
 #include "ParameterAccessContext.h"
 #include <assert.h>
+#include "ParameterAdaptation.h"
 
 #define base CParameterType
 
@@ -41,11 +42,18 @@ CIntegerParameterType::CIntegerParameterType(const string& strName) : base(strNa
 {
 }
 
+// Kind
 string CIntegerParameterType::getKind() const
 {
     return "IntegerParameter";
 }
 
+// Deal with adaption node
+bool CIntegerParameterType::childrenAreDynamic() const
+{
+    return true;
+}
+
 // Element properties
 void CIntegerParameterType::showProperties(string& strResult) const
 {
@@ -65,6 +73,17 @@ void CIntegerParameterType::showProperties(string& strResult) const
     strResult += "Max: ";
     strResult += _bSigned ? toString((int32_t)_uiMax) : toString(_uiMax);
     strResult += "\n";
+
+    // Check if there's an adaptation object available
+    const CParameterAdaptation* pParameterAdaption = getParameterAdaptation();
+
+    if (pParameterAdaption) {
+
+        // Display adaptation properties
+        strResult += "Adaptation:\n";
+
+        pParameterAdaption->showProperties(strResult);
+    }
 }
 
 bool CIntegerParameterType::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
@@ -227,6 +246,7 @@ bool CIntegerParameterType::fromBlackboard(uint32_t& uiUserValue, uint32_t uiVal
 
         return false;
     }
+    // Do assign
     uiUserValue = uiValue;
 
     return true;
@@ -266,11 +286,84 @@ bool CIntegerParameterType::fromBlackboard(int32_t& iUserValue, uint32_t uiValue
     // Sign extend
     signExtend(iValue);
 
+    // Do assign
     iUserValue = iValue;
 
     return true;
 }
 
+// Double
+bool CIntegerParameterType::toBlackboard(double dUserValue, uint32_t& uiValue, CParameterAccessContext& parameterAccessContext) const
+{
+    // Check if there's an adaptation object available
+    const CParameterAdaptation* pParameterAdaption = getParameterAdaptation();
+
+    if (!pParameterAdaption) {
+
+        // Reject request and let upper class handle the error
+        return base::toBlackboard(dUserValue, uiValue, parameterAccessContext);
+    }
+
+    // Do the conversion
+    int64_t iConvertedValue = pParameterAdaption->fromUserValue(dUserValue);
+
+    // Check against range
+    if (_bSigned) {
+
+        if (iConvertedValue < (int32_t)_uiMin || iConvertedValue > (int32_t)_uiMax) {
+
+            parameterAccessContext.setError("Value out of range");
+
+            return false;
+        }
+    } else {
+
+        if (iConvertedValue < _uiMin || iConvertedValue > _uiMax) {
+
+            parameterAccessContext.setError("Value out of range");
+
+            return false;
+        }
+    }
+
+    // Do assign
+    uiValue = (uint32_t)iConvertedValue;
+
+    return true;
+}
+
+bool CIntegerParameterType::fromBlackboard(double& dUserValue, uint32_t uiValue, CParameterAccessContext& parameterAccessContext) const
+{
+    // Check if there's an adaptation object available
+    const CParameterAdaptation* pParameterAdaption = getParameterAdaptation();
+
+    if (!pParameterAdaption) {
+
+        // Reject request and let upper class handle the error
+        return base::fromBlackboard(dUserValue, uiValue, parameterAccessContext);
+    }
+
+    int64_t iValueToConvert;
+
+    // Deal with signed data
+    if (_bSigned) {
+
+        int32_t iValue = uiValue;
+
+        signExtend(iValue);
+
+        iValueToConvert = iValue;
+    } else {
+
+        iValueToConvert = uiValue;
+    }
+
+    // Do the conversion
+    dUserValue = pParameterAdaption->toUserValue(iValueToConvert);
+
+    return true;
+}
+
 // Default value handling (simulation only)
 uint32_t CIntegerParameterType::getDefaultValue() const
 {
@@ -306,3 +399,9 @@ template <typename type> bool CIntegerParameterType::checkValueAgainstRange(cons
     }
     return true;
 }
+
+// Adaptation element retrieval
+const CParameterAdaptation* CIntegerParameterType::getParameterAdaptation() const
+{
+    return static_cast<const CParameterAdaptation*>(findChildOfKind("Adaptation"));
+}