|
16 | 16 | */
|
17 | 17 |
|
18 | 18 | #include <app/clusters/scenes-server/SceneHandlerImpl.h>
|
| 19 | +#include <app/util/endpoint-config-api.h> |
| 20 | +#include <app/util/odd-sized-integers.h> |
19 | 21 |
|
20 | 22 | namespace chip {
|
21 | 23 | namespace scenes {
|
22 | 24 |
|
| 25 | +namespace { |
| 26 | + |
| 27 | +template <int ByteSize, bool IsSigned> |
| 28 | +using OddSizedInteger = app::OddSizedInteger<ByteSize, IsSigned>; |
| 29 | +using ConcreteAttributePath = app::ConcreteAttributePath; |
| 30 | +using AttributeValuePairType = app::Clusters::ScenesManagement::Structs::AttributeValuePairStruct::Type; |
| 31 | + |
| 32 | +/// ConvertDefaultValueToWorkingValue |
| 33 | +/// @brief Helper function to convert a byte array to a value of the given type. |
| 34 | +/// @param EmberAfDefaultAttributeValue & defaultValue |
| 35 | +/// @return Value converted to the given working type |
| 36 | +template <typename Type> |
| 37 | +typename app::NumericAttributeTraits<Type>::WorkingType |
| 38 | +ConvertDefaultValueToWorkingValue(const EmberAfDefaultAttributeValue & defaultValue) |
| 39 | +{ |
| 40 | + if (sizeof(typename app::NumericAttributeTraits<Type>::WorkingType) <= 2) |
| 41 | + { |
| 42 | + return static_cast<typename app::NumericAttributeTraits<Type>::WorkingType>(defaultValue.defaultValue); |
| 43 | + } |
| 44 | + |
| 45 | + typename app::NumericAttributeTraits<Type>::StorageType sValue; |
| 46 | + memcpy(&sValue, defaultValue.ptrToDefaultValue, sizeof(sValue)); |
| 47 | + return app::NumericAttributeTraits<Type>::StorageToWorking(sValue); |
| 48 | +} |
| 49 | + |
| 50 | +/// IsOnlyOneValuePopulated |
| 51 | +/// @brief Helper function to verify if only one value is populated in a given AttributeValuePairType |
| 52 | +/// @param AttributeValuePairType & type AttributeValuePairType to verify |
| 53 | +/// @return bool true if only one value is populated, false otherwise |
| 54 | +bool IsOnlyOneValuePopulated(const AttributeValuePairType & type) |
| 55 | +{ |
| 56 | + int count = 0; |
| 57 | + if (type.valueUnsigned8.HasValue()) |
| 58 | + count++; |
| 59 | + if (type.valueSigned8.HasValue()) |
| 60 | + count++; |
| 61 | + if (type.valueUnsigned16.HasValue()) |
| 62 | + count++; |
| 63 | + if (type.valueSigned16.HasValue()) |
| 64 | + count++; |
| 65 | + if (type.valueUnsigned32.HasValue()) |
| 66 | + count++; |
| 67 | + if (type.valueSigned32.HasValue()) |
| 68 | + count++; |
| 69 | + if (type.valueUnsigned64.HasValue()) |
| 70 | + count++; |
| 71 | + if (type.valueSigned64.HasValue()) |
| 72 | + count++; |
| 73 | + return count == 1; |
| 74 | +} |
| 75 | + |
| 76 | +/// CapAttributeID |
| 77 | +/// Cap the attribute value based on the attribute's min and max if they are defined, |
| 78 | +/// or based on the attribute's size if they are not. |
| 79 | +/// @param[in] aVPair AttributeValuePairType |
| 80 | +/// @param[in] metadata EmberAfAttributeMetadata |
| 81 | +/// |
| 82 | +template <typename Type> |
| 83 | +void CapAttributeID(typename app::NumericAttributeTraits<Type>::WorkingType & Value, const EmberAfAttributeMetadata * metadata) |
| 84 | +{ |
| 85 | + using IntType = app::NumericAttributeTraits<Type>; |
| 86 | + using WorkingType = typename IntType::WorkingType; |
| 87 | + |
| 88 | + WorkingType maxValue; |
| 89 | + WorkingType minValue; |
| 90 | + uint16_t bitWidth = static_cast<uint16_t>(emberAfAttributeSize(metadata) * 8); |
| 91 | + |
| 92 | + // Min/Max Value capps for the OddSize integers |
| 93 | + if (metadata->IsSignedIntegerAttribute()) |
| 94 | + { |
| 95 | + // We use emberAfAttributeSize for cases like INT24S, INT40S, INT48S, INT56S where numeric_limits<WorkingType>::max() |
| 96 | + // wouldn't work |
| 97 | + maxValue = static_cast<WorkingType>((1ULL << (bitWidth - 1)) - 1); |
| 98 | + minValue = static_cast<WorkingType>(-(1ULL << (bitWidth - 1))); |
| 99 | + } |
| 100 | + else |
| 101 | + { |
| 102 | + // We use emberAfAttributeSize for cases like INT24U, INT40U, INT48U, INT56U where numeric_limits<WorkingType>::max() |
| 103 | + // wouldn't work |
| 104 | + if (ZCL_INT64U_ATTRIBUTE_TYPE == metadata->attributeType) |
| 105 | + { |
| 106 | + maxValue = static_cast<WorkingType>(UINT64_MAX); // Bit shift of 64 is undefined so we use UINT64_MAX |
| 107 | + } |
| 108 | + else |
| 109 | + { |
| 110 | + maxValue = static_cast<WorkingType>((1ULL << bitWidth) - 1); |
| 111 | + } |
| 112 | + minValue = static_cast<WorkingType>(0); |
| 113 | + } |
| 114 | + |
| 115 | + // Ensure that the metadata's signedness matches the working type's signedness |
| 116 | + VerifyOrDie(metadata->IsSignedIntegerAttribute() == std::is_signed<WorkingType>::value); |
| 117 | + |
| 118 | + if (metadata->IsBoolean()) |
| 119 | + { |
| 120 | + // Caping the value to 1 in case values greater than 1 are set |
| 121 | + Value = Value ? 1 : 0; |
| 122 | + return; |
| 123 | + } |
| 124 | + |
| 125 | + // Check metadata for min and max values |
| 126 | + if (metadata->HasMinMax()) |
| 127 | + { |
| 128 | + const EmberAfAttributeMinMaxValue * minMaxValue = metadata->defaultValue.ptrToMinMaxValue; |
| 129 | + minValue = ConvertDefaultValueToWorkingValue<Type>(minMaxValue->minValue); |
| 130 | + maxValue = ConvertDefaultValueToWorkingValue<Type>(minMaxValue->maxValue); |
| 131 | + } |
| 132 | + |
| 133 | + if (minValue > Value) |
| 134 | + { |
| 135 | + Value = minValue; |
| 136 | + } |
| 137 | + else if (maxValue < Value) |
| 138 | + { |
| 139 | + Value = maxValue; |
| 140 | + } |
| 141 | +} |
| 142 | + |
| 143 | +/// @brief Validate the attribute exists for a given cluster |
| 144 | +/// @param[in] endpoint Endpoint ID |
| 145 | +/// @param[in] clusterID Cluster ID |
| 146 | +/// @param[in] aVPair AttributeValuePairType, will be mutated to cap the value if it is out of range |
| 147 | +/// @return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute) if the attribute does not exist for a given cluster or is not scenable |
| 148 | +/// @note This will allways fail for global list attributes. If we do want to make them scenable someday, we will need to |
| 149 | +/// use a different validation method. |
| 150 | +// TODO: Add check for "S" quality to determine if the attribute is scenable once suported : |
| 151 | +// https://github.com/project-chip/connectedhomeip/issues/24177 |
| 152 | +CHIP_ERROR ValidateAttributePath(EndpointId endpoint, ClusterId cluster, AttributeValuePairType & aVPair) |
| 153 | +{ |
| 154 | + const EmberAfAttributeMetadata * metadata = emberAfLocateAttributeMetadata(endpoint, cluster, aVPair.attributeID); |
| 155 | + |
| 156 | + if (nullptr == metadata) |
| 157 | + { |
| 158 | + return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); |
| 159 | + } |
| 160 | + |
| 161 | + // There should never be more than one populated value in an ExtensionFieldSet |
| 162 | + VerifyOrReturnError(IsOnlyOneValuePopulated(aVPair), CHIP_ERROR_INVALID_ARGUMENT); |
| 163 | + |
| 164 | + switch (metadata->attributeType) |
| 165 | + { |
| 166 | + case ZCL_BOOLEAN_ATTRIBUTE_TYPE: |
| 167 | + case ZCL_BITMAP8_ATTRIBUTE_TYPE: |
| 168 | + case ZCL_ENUM8_ATTRIBUTE_TYPE: |
| 169 | + case ZCL_INT8U_ATTRIBUTE_TYPE: |
| 170 | + VerifyOrReturnError(aVPair.valueUnsigned8.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 171 | + CapAttributeID<uint8_t>(aVPair.valueUnsigned8.Value(), metadata); |
| 172 | + break; |
| 173 | + case ZCL_BITMAP16_ATTRIBUTE_TYPE: |
| 174 | + case ZCL_ENUM16_ATTRIBUTE_TYPE: |
| 175 | + case ZCL_INT16U_ATTRIBUTE_TYPE: |
| 176 | + VerifyOrReturnError(aVPair.valueUnsigned16.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 177 | + CapAttributeID<uint16_t>(aVPair.valueUnsigned16.Value(), metadata); |
| 178 | + break; |
| 179 | + case ZCL_INT24U_ATTRIBUTE_TYPE: |
| 180 | + VerifyOrReturnError(aVPair.valueUnsigned32.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 181 | + CapAttributeID<OddSizedInteger<3, false>>(aVPair.valueUnsigned32.Value(), metadata); |
| 182 | + break; |
| 183 | + case ZCL_BITMAP32_ATTRIBUTE_TYPE: |
| 184 | + case ZCL_INT32U_ATTRIBUTE_TYPE: |
| 185 | + VerifyOrReturnError(aVPair.valueUnsigned32.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 186 | + CapAttributeID<uint32_t>(aVPair.valueUnsigned32.Value(), metadata); |
| 187 | + break; |
| 188 | + case ZCL_INT48U_ATTRIBUTE_TYPE: |
| 189 | + VerifyOrReturnError(aVPair.valueUnsigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 190 | + CapAttributeID<OddSizedInteger<6, false>>(aVPair.valueUnsigned64.Value(), metadata); |
| 191 | + break; |
| 192 | + case ZCL_INT56U_ATTRIBUTE_TYPE: |
| 193 | + VerifyOrReturnError(aVPair.valueUnsigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 194 | + CapAttributeID<OddSizedInteger<7, false>>(aVPair.valueUnsigned64.Value(), metadata); |
| 195 | + break; |
| 196 | + case ZCL_BITMAP64_ATTRIBUTE_TYPE: |
| 197 | + case ZCL_INT64U_ATTRIBUTE_TYPE: |
| 198 | + VerifyOrReturnError(aVPair.valueUnsigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 199 | + CapAttributeID<uint64_t>(aVPair.valueUnsigned64.Value(), metadata); |
| 200 | + break; |
| 201 | + case ZCL_INT8S_ATTRIBUTE_TYPE: |
| 202 | + VerifyOrReturnError(aVPair.valueSigned8.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 203 | + CapAttributeID<int8_t>(aVPair.valueSigned8.Value(), metadata); |
| 204 | + break; |
| 205 | + case ZCL_INT16S_ATTRIBUTE_TYPE: |
| 206 | + VerifyOrReturnError(aVPair.valueSigned16.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 207 | + CapAttributeID<int16_t>(aVPair.valueSigned16.Value(), metadata); |
| 208 | + break; |
| 209 | + case ZCL_INT24S_ATTRIBUTE_TYPE: |
| 210 | + VerifyOrReturnError(aVPair.valueSigned32.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 211 | + CapAttributeID<OddSizedInteger<3, true>>(aVPair.valueSigned32.Value(), metadata); |
| 212 | + break; |
| 213 | + case ZCL_INT32S_ATTRIBUTE_TYPE: |
| 214 | + VerifyOrReturnError(aVPair.valueSigned32.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 215 | + CapAttributeID<int32_t>(aVPair.valueSigned32.Value(), metadata); |
| 216 | + break; |
| 217 | + case ZCL_INT48S_ATTRIBUTE_TYPE: |
| 218 | + VerifyOrReturnError(aVPair.valueSigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 219 | + CapAttributeID<OddSizedInteger<6, true>>(aVPair.valueSigned64.Value(), metadata); |
| 220 | + break; |
| 221 | + case ZCL_INT56S_ATTRIBUTE_TYPE: |
| 222 | + VerifyOrReturnError(aVPair.valueSigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 223 | + CapAttributeID<OddSizedInteger<7, true>>(aVPair.valueSigned64.Value(), metadata); |
| 224 | + break; |
| 225 | + case ZCL_INT64S_ATTRIBUTE_TYPE: |
| 226 | + VerifyOrReturnError(aVPair.valueSigned64.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); |
| 227 | + CapAttributeID<int64_t>(aVPair.valueSigned64.Value(), metadata); |
| 228 | + break; |
| 229 | + default: |
| 230 | + return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); |
| 231 | + } |
| 232 | + |
| 233 | + return CHIP_NO_ERROR; |
| 234 | +} |
| 235 | +} // namespace |
| 236 | + |
23 | 237 | CHIP_ERROR
|
24 | 238 | DefaultSceneHandlerImpl::EncodeAttributeValueList(const List<AttributeValuePairType> & aVlist, MutableByteSpan & serializedBytes)
|
25 | 239 | {
|
@@ -58,7 +272,9 @@ DefaultSceneHandlerImpl::SerializeAdd(EndpointId endpoint, const ExtensionFieldS
|
58 | 272 | auto pair_iterator = extensionFieldSet.attributeValueList.begin();
|
59 | 273 | while (pair_iterator.Next())
|
60 | 274 | {
|
61 |
| - aVPairs[pairCount] = pair_iterator.GetValue(); |
| 275 | + AttributeValuePairType currentPair = pair_iterator.GetValue(); |
| 276 | + ReturnErrorOnFailure(ValidateAttributePath(endpoint, extensionFieldSet.clusterID, currentPair)); |
| 277 | + aVPairs[pairCount] = currentPair; |
62 | 278 | pairCount++;
|
63 | 279 | }
|
64 | 280 | ReturnErrorOnFailure(pair_iterator.GetStatus());
|
|
0 commit comments