1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "drag_data_packer.h"
17
18 #include "devicestatus_common.h"
19 #include "devicestatus_define.h"
20 #include "devicestatus_errors.h"
21
22 #undef LOG_TAG
23 #define LOG_TAG "DragDataPacker"
24
25 namespace OHOS {
26 namespace Msdp {
27 namespace DeviceStatus {
28
Marshalling(const DragData & dragData,Parcel & data,bool isCross)29 int32_t DragDataPacker::Marshalling(const DragData &dragData, Parcel &data, bool isCross)
30 {
31 CALL_DEBUG_ENTER;
32 if (ShadowPacker::Marshalling(dragData.shadowInfos, data, isCross) != RET_OK) {
33 FI_HILOGE("Marshalling shadowInfos failed");
34 return RET_ERR;
35 }
36 if (!isCross) {
37 if (dragData.toolType < SourceTool::UNKNOWN || dragData.toolType > SourceTool::JOYSTICK) {
38 FI_HILOGE("toolType error");
39 return RET_ERR;
40 }
41 WRITEINT32(data, dragData.toolType, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
42 }
43 WRITEUINT8VECTOR(data, dragData.buffer, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
44 WRITESTRING(data, dragData.udKey, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
45 WRITESTRING(data, dragData.extraInfo, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
46 WRITESTRING(data, dragData.filterInfo, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
47 WRITEINT32(data, dragData.sourceType, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
48 WRITEINT32(data, dragData.dragNum, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
49 WRITEINT32(data, dragData.pointerId, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
50 WRITEINT32(data, dragData.displayX, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
51 WRITEINT32(data, dragData.displayY, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
52 WRITEINT32(data, dragData.displayId, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
53 WRITEINT32(data, dragData.mainWindow, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
54 WRITEBOOL(data, dragData.hasCanceledAnimation, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
55 WRITEBOOL(data, dragData.hasCoordinateCorrected, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
56 if (SummaryPacker::Marshalling(dragData.summarys, data) != RET_OK) {
57 FI_HILOGE("Marshalling summary failed");
58 return RET_ERR;
59 }
60 return RET_OK;
61 }
62
UnMarshalling(Parcel & data,DragData & dragData,bool isCross)63 int32_t DragDataPacker::UnMarshalling(Parcel &data, DragData &dragData, bool isCross)
64 {
65 CALL_DEBUG_ENTER;
66 if (ShadowPacker::UnMarshalling(data, dragData.shadowInfos, isCross) != RET_OK) {
67 FI_HILOGE("UnMarshalling shadowInfos failed");
68 return RET_ERR;
69 }
70 if (!isCross) {
71 READINT32(data, dragData.toolType, E_DEVICESTATUS_READ_PARCEL_ERROR);
72 }
73 READUINT8VECTOR(data, dragData.buffer, E_DEVICESTATUS_READ_PARCEL_ERROR);
74 READSTRING(data, dragData.udKey, E_DEVICESTATUS_READ_PARCEL_ERROR);
75 READSTRING(data, dragData.extraInfo, E_DEVICESTATUS_READ_PARCEL_ERROR);
76 READSTRING(data, dragData.filterInfo, E_DEVICESTATUS_READ_PARCEL_ERROR);
77 READINT32(data, dragData.sourceType, E_DEVICESTATUS_READ_PARCEL_ERROR);
78 READINT32(data, dragData.dragNum, E_DEVICESTATUS_READ_PARCEL_ERROR);
79 READINT32(data, dragData.pointerId, E_DEVICESTATUS_READ_PARCEL_ERROR);
80 READINT32(data, dragData.displayX, E_DEVICESTATUS_READ_PARCEL_ERROR);
81 READINT32(data, dragData.displayY, E_DEVICESTATUS_READ_PARCEL_ERROR);
82 READINT32(data, dragData.displayId, E_DEVICESTATUS_READ_PARCEL_ERROR);
83 READINT32(data, dragData.mainWindow, E_DEVICESTATUS_READ_PARCEL_ERROR);
84 READBOOL(data, dragData.hasCanceledAnimation, E_DEVICESTATUS_READ_PARCEL_ERROR);
85 READBOOL(data, dragData.hasCoordinateCorrected, E_DEVICESTATUS_READ_PARCEL_ERROR);
86 if (SummaryPacker::UnMarshalling(data, dragData.summarys) != RET_OK) {
87 FI_HILOGE("Unmarshalling summary failed");
88 return RET_ERR;
89 }
90 return RET_OK;
91 }
92
CheckDragData(const DragData & dragData)93 int32_t DragDataPacker::CheckDragData(const DragData &dragData)
94 {
95 for (const auto& shadowInfo : dragData.shadowInfos) {
96 if (ShadowPacker::CheckShadowInfo(shadowInfo) != RET_OK) {
97 FI_HILOGE("CheckShadowInfo failed");
98 return RET_ERR;
99 }
100 }
101 if ((dragData.dragNum <= 0) || (dragData.buffer.size() > MAX_BUFFER_SIZE) ||
102 (dragData.displayX < 0) || (dragData.displayY < 0)) {
103 FI_HILOGE("Start drag invalid parameter, dragNum:%{public}d, bufferSize:%{public}zu, "
104 "displayX:%{private}d, displayY:%{private}d",
105 dragData.dragNum, dragData.buffer.size(), dragData.displayX, dragData.displayY);
106 return RET_ERR;
107 }
108 return RET_OK;
109 }
110
Marshalling(const std::vector<ShadowInfo> & shadowInfos,Parcel & data,bool isCross)111 int32_t ShadowPacker::Marshalling(const std::vector<ShadowInfo> &shadowInfos, Parcel &data, bool isCross)
112 {
113 CALL_DEBUG_ENTER;
114 if (shadowInfos.empty()) {
115 FI_HILOGE("Invalid parameter shadowInfos");
116 return ERR_INVALID_VALUE;
117 }
118 int32_t shadowNum = static_cast<int32_t>(shadowInfos.size());
119 if (shadowNum > SHADOW_NUM_LIMIT) {
120 FI_HILOGW("Only %{public}d shadowInfos allowed at most, now %{public}d", SHADOW_NUM_LIMIT, shadowNum);
121 shadowNum = SHADOW_NUM_LIMIT;
122 }
123 WRITEINT32(data, shadowNum, ERR_INVALID_VALUE);
124 for (int32_t i = 0; i < shadowNum; i++) {
125 if (PackUpShadowInfo(shadowInfos[i], data, isCross) != RET_OK) {
126 FI_HILOGE("PackUpShadowInfo No.%{public}d failed", i);
127 return RET_ERR;
128 }
129 }
130 return RET_OK;
131 }
132
UnMarshalling(Parcel & data,std::vector<ShadowInfo> & shadowInfos,bool isCross)133 int32_t ShadowPacker::UnMarshalling(Parcel &data, std::vector<ShadowInfo> &shadowInfos, bool isCross)
134 {
135 CALL_DEBUG_ENTER;
136 int32_t shadowNum { 0 };
137 READINT32(data, shadowNum, E_DEVICESTATUS_READ_PARCEL_ERROR);
138 if (shadowNum <= 0 || shadowNum > SHADOW_NUM_LIMIT) {
139 FI_HILOGE("Invalid shadowNum:%{public}d", shadowNum);
140 return RET_ERR;
141 }
142 for (int32_t i = 0; i < shadowNum; i++) {
143 ShadowInfo shadowInfo;
144 if (UnPackShadowInfo(data, shadowInfo, isCross) != RET_OK) {
145 FI_HILOGE("UnPackShadowInfo No.%{public}d failed", i);
146 return RET_ERR;
147 }
148 CHKPR(shadowInfo.pixelMap, RET_ERR);
149 shadowInfos.push_back(shadowInfo);
150 }
151 return RET_OK;
152 }
153
PackUpShadowInfo(const ShadowInfo & shadowInfo,Parcel & data,bool isCross)154 int32_t ShadowPacker::PackUpShadowInfo(const ShadowInfo &shadowInfo, Parcel &data, bool isCross)
155 {
156 CALL_DEBUG_ENTER;
157 CHKPR(shadowInfo.pixelMap, RET_ERR);
158 if (isCross) {
159 FI_HILOGD("By EncodeTlv");
160 std::vector<uint8_t> pixelBuffer;
161 if (!shadowInfo.pixelMap->EncodeTlv(pixelBuffer)) {
162 FI_HILOGE("EncodeTlv pixelMap failed");
163 return ERR_INVALID_VALUE;
164 }
165 WRITEUINT8VECTOR(data, pixelBuffer, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
166 } else {
167 FI_HILOGD("By Marshalling");
168 if (!shadowInfo.pixelMap->Marshalling(data)) {
169 FI_HILOGE("Marshalling pixelMap failed");
170 return ERR_INVALID_VALUE;
171 }
172 }
173 WRITEINT32(data, shadowInfo.x, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
174 WRITEINT32(data, shadowInfo.y, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
175 return RET_OK;
176 }
177
UnPackShadowInfo(Parcel & data,ShadowInfo & shadowInfo,bool isCross)178 int32_t ShadowPacker::UnPackShadowInfo(Parcel &data, ShadowInfo &shadowInfo, bool isCross)
179 {
180 CALL_DEBUG_ENTER;
181 Media::PixelMap *rawPixelMap = nullptr;
182 if (isCross) {
183 FI_HILOGD("By DecodeTlv");
184 std::vector<uint8_t> pixelBuffer;
185 READUINT8VECTOR(data, pixelBuffer, ERR_INVALID_VALUE);
186 rawPixelMap = Media::PixelMap::DecodeTlv(pixelBuffer);
187 } else {
188 FI_HILOGD("By UnMarshalling");
189 rawPixelMap = OHOS::Media::PixelMap::Unmarshalling(data);
190 }
191 CHKPR(rawPixelMap, RET_ERR);
192 shadowInfo.pixelMap = std::shared_ptr<Media::PixelMap>(rawPixelMap);
193 CHKPR(shadowInfo.pixelMap, RET_ERR);
194 READINT32(data, shadowInfo.x, E_DEVICESTATUS_READ_PARCEL_ERROR);
195 READINT32(data, shadowInfo.y, E_DEVICESTATUS_READ_PARCEL_ERROR);
196 return RET_OK;
197 }
198
CheckShadowInfo(const ShadowInfo & shadowInfo)199 int32_t ShadowPacker::CheckShadowInfo(const ShadowInfo &shadowInfo)
200 {
201 CHKPR(shadowInfo.pixelMap, RET_ERR);
202 if ((shadowInfo.x > 0) || (shadowInfo.y > 0) ||
203 (shadowInfo.x < -shadowInfo.pixelMap->GetWidth()) || (shadowInfo.y < -shadowInfo.pixelMap->GetHeight())) {
204 FI_HILOGE("Invalid parameter, shadowInfoX:%{private}d, shadowInfoY:%{private}d", shadowInfo.x, shadowInfo.y);
205 return RET_ERR;
206 }
207 return RET_OK;
208 }
209
Marshalling(const SummaryMap & val,Parcel & parcel)210 int32_t SummaryPacker::Marshalling(const SummaryMap &val, Parcel &parcel)
211 {
212 WRITEINT32(parcel, static_cast<int32_t>(val.size()), ERR_INVALID_VALUE);
213 for (auto const &[k, v] : val) {
214 WRITESTRING(parcel, k, ERR_INVALID_VALUE);
215 WRITEINT64(parcel, v, ERR_INVALID_VALUE);
216 }
217 return RET_OK;
218 }
219
UnMarshalling(Parcel & parcel,SummaryMap & val)220 int32_t SummaryPacker::UnMarshalling(Parcel &parcel, SummaryMap &val)
221 {
222 size_t readAbleSize = parcel.GetReadableBytes();
223 int32_t size = 0;
224 READINT32(parcel, size, E_DEVICESTATUS_READ_PARCEL_ERROR);
225 if (size < 0 || (static_cast<size_t>(size) > readAbleSize) || static_cast<size_t>(size) > val.max_size()) {
226 FI_HILOGE("Invalid size:%{public}d", size);
227 return RET_ERR;
228 }
229 for (int32_t i = 0; i < size; ++i) {
230 std::string key;
231 READSTRING(parcel, key, E_DEVICESTATUS_READ_PARCEL_ERROR);
232 READINT64(parcel, val[key], E_DEVICESTATUS_READ_PARCEL_ERROR);
233 }
234 return RET_OK;
235 }
236
Marshalling(const ShadowOffset & shadowOffset,Parcel & parcel)237 int32_t ShadowOffsetPacker::Marshalling(const ShadowOffset&shadowOffset, Parcel &parcel)
238 {
239 WRITEINT32(parcel, shadowOffset.offsetX, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
240 WRITEINT32(parcel, shadowOffset.offsetY, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
241 WRITEINT32(parcel, shadowOffset.width, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
242 WRITEINT32(parcel, shadowOffset.height, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
243 return RET_OK;
244 }
245
UnMarshalling(Parcel & parcel,ShadowOffset & shadowOffset)246 int32_t ShadowOffsetPacker::UnMarshalling(Parcel &parcel, ShadowOffset&shadowOffset)
247 {
248 READINT32(parcel, shadowOffset.offsetX, E_DEVICESTATUS_READ_PARCEL_ERROR);
249 READINT32(parcel, shadowOffset.offsetY, E_DEVICESTATUS_READ_PARCEL_ERROR);
250 READINT32(parcel, shadowOffset.width, E_DEVICESTATUS_READ_PARCEL_ERROR);
251 READINT32(parcel, shadowOffset.height, E_DEVICESTATUS_READ_PARCEL_ERROR);
252 return RET_OK;
253 }
254 } // namespace DeviceStatus
255 } // namespace Msdp
256 } // namespace OHOS
257