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     WRITEUINT8VECTOR(data, dragData.buffer, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
37     WRITESTRING(data, dragData.udKey, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
38     WRITESTRING(data, dragData.extraInfo, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
39     WRITESTRING(data, dragData.filterInfo, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
40     WRITEINT32(data, dragData.sourceType, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
41     WRITEINT32(data, dragData.dragNum, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
42     WRITEINT32(data, dragData.pointerId, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
43     WRITEINT32(data, dragData.displayX, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
44     WRITEINT32(data, dragData.displayY, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
45     WRITEINT32(data, dragData.displayId, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
46     WRITEINT32(data, dragData.mainWindow, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
47     WRITEBOOL(data, dragData.hasCanceledAnimation, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
48     WRITEBOOL(data, dragData.hasCoordinateCorrected, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
49     if (SummaryPacker::Marshalling(dragData.summarys, data) != RET_OK) {
50         FI_HILOGE("Marshalling summary failed");
51         return RET_ERR;
52     }
53     return RET_OK;
54 }
55 
UnMarshalling(Parcel & data,DragData & dragData,bool isCross)56 int32_t DragDataPacker::UnMarshalling(Parcel &data, DragData &dragData, bool isCross)
57 {
58     CALL_DEBUG_ENTER;
59     if (ShadowPacker::UnMarshalling(data, dragData.shadowInfos, isCross) != RET_OK) {
60         FI_HILOGE("UnMarshalling shadowInfos failed");
61         return RET_ERR;
62     }
63     READUINT8VECTOR(data, dragData.buffer, E_DEVICESTATUS_READ_PARCEL_ERROR);
64     READSTRING(data, dragData.udKey, E_DEVICESTATUS_READ_PARCEL_ERROR);
65     READSTRING(data, dragData.extraInfo, E_DEVICESTATUS_READ_PARCEL_ERROR);
66     READSTRING(data, dragData.filterInfo, E_DEVICESTATUS_READ_PARCEL_ERROR);
67     READINT32(data, dragData.sourceType, E_DEVICESTATUS_READ_PARCEL_ERROR);
68     READINT32(data, dragData.dragNum, E_DEVICESTATUS_READ_PARCEL_ERROR);
69     READINT32(data, dragData.pointerId, E_DEVICESTATUS_READ_PARCEL_ERROR);
70     READINT32(data, dragData.displayX, E_DEVICESTATUS_READ_PARCEL_ERROR);
71     READINT32(data, dragData.displayY, E_DEVICESTATUS_READ_PARCEL_ERROR);
72     READINT32(data, dragData.displayId, E_DEVICESTATUS_READ_PARCEL_ERROR);
73     READINT32(data, dragData.mainWindow, E_DEVICESTATUS_READ_PARCEL_ERROR);
74     READBOOL(data, dragData.hasCanceledAnimation, E_DEVICESTATUS_READ_PARCEL_ERROR);
75     READBOOL(data, dragData.hasCoordinateCorrected, E_DEVICESTATUS_READ_PARCEL_ERROR);
76     if (SummaryPacker::UnMarshalling(data, dragData.summarys) != RET_OK) {
77         FI_HILOGE("Unmarshalling summary failed");
78         return RET_ERR;
79     }
80     return RET_OK;
81 }
82 
CheckDragData(const DragData & dragData)83 int32_t DragDataPacker::CheckDragData(const DragData &dragData)
84 {
85     for (const auto& shadowInfo : dragData.shadowInfos) {
86         if (ShadowPacker::CheckShadowInfo(shadowInfo) != RET_OK) {
87             FI_HILOGE("CheckShadowInfo failed");
88             return RET_ERR;
89         }
90     }
91     if ((dragData.dragNum <= 0) || (dragData.buffer.size() > MAX_BUFFER_SIZE) ||
92         (dragData.displayX < 0) || (dragData.displayY < 0)) {
93         FI_HILOGE("Start drag invalid parameter, dragNum:%{public}d, bufferSize:%{public}zu, "
94             "displayX:%{private}d, displayY:%{private}d",
95             dragData.dragNum, dragData.buffer.size(), dragData.displayX, dragData.displayY);
96         return RET_ERR;
97     }
98     return RET_OK;
99 }
100 
Marshalling(const std::vector<ShadowInfo> & shadowInfos,Parcel & data,bool isCross)101 int32_t ShadowPacker::Marshalling(const std::vector<ShadowInfo> &shadowInfos, Parcel &data, bool isCross)
102 {
103     CALL_DEBUG_ENTER;
104     if (shadowInfos.empty()) {
105         FI_HILOGE("Invalid parameter shadowInfos");
106         return ERR_INVALID_VALUE;
107     }
108     int32_t shadowNum = static_cast<int32_t>(shadowInfos.size());
109     if (shadowNum > SHADOW_NUM_LIMIT) {
110         FI_HILOGW("Only %{public}d shadowInfos allowed at most, now %{public}d", SHADOW_NUM_LIMIT, shadowNum);
111         shadowNum = SHADOW_NUM_LIMIT;
112     }
113     WRITEINT32(data, shadowNum, ERR_INVALID_VALUE);
114     for (int32_t i = 0; i < shadowNum; i++) {
115         if (PackUpShadowInfo(shadowInfos[i], data, isCross) != RET_OK) {
116             FI_HILOGE("PackUpShadowInfo No.%{public}d failed", i);
117             return RET_ERR;
118         }
119     }
120     return RET_OK;
121 }
122 
UnMarshalling(Parcel & data,std::vector<ShadowInfo> & shadowInfos,bool isCross)123 int32_t ShadowPacker::UnMarshalling(Parcel &data, std::vector<ShadowInfo> &shadowInfos, bool isCross)
124 {
125     CALL_DEBUG_ENTER;
126     int32_t shadowNum { 0 };
127     READINT32(data, shadowNum, E_DEVICESTATUS_READ_PARCEL_ERROR);
128     if (shadowNum <= 0 || shadowNum > SHADOW_NUM_LIMIT) {
129         FI_HILOGE("Invalid shadowNum:%{public}d", shadowNum);
130         return RET_ERR;
131     }
132     for (int32_t i = 0; i < shadowNum; i++) {
133         ShadowInfo shadowInfo;
134         if (UnPackShadowInfo(data, shadowInfo, isCross) != RET_OK) {
135             FI_HILOGE("UnPackShadowInfo No.%{public}d failed", i);
136             return RET_ERR;
137         }
138         CHKPR(shadowInfo.pixelMap, RET_ERR);
139         shadowInfos.push_back(shadowInfo);
140     }
141     return RET_OK;
142 }
143 
PackUpShadowInfo(const ShadowInfo & shadowInfo,Parcel & data,bool isCross)144 int32_t ShadowPacker::PackUpShadowInfo(const ShadowInfo &shadowInfo, Parcel &data, bool isCross)
145 {
146     CALL_DEBUG_ENTER;
147     CHKPR(shadowInfo.pixelMap, RET_ERR);
148     if (isCross) {
149         FI_HILOGD("By EncodeTlv");
150         std::vector<uint8_t> pixelBuffer;
151         if (!shadowInfo.pixelMap->EncodeTlv(pixelBuffer)) {
152             FI_HILOGE("EncodeTlv pixelMap failed");
153             return ERR_INVALID_VALUE;
154         }
155         WRITEUINT8VECTOR(data, pixelBuffer, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
156     } else {
157         FI_HILOGD("By Marshalling");
158         if (!shadowInfo.pixelMap->Marshalling(data)) {
159             FI_HILOGE("Marshalling pixelMap failed");
160             return ERR_INVALID_VALUE;
161         }
162     }
163     WRITEINT32(data, shadowInfo.x, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
164     WRITEINT32(data, shadowInfo.y, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
165     return RET_OK;
166 }
167 
UnPackShadowInfo(Parcel & data,ShadowInfo & shadowInfo,bool isCross)168 int32_t ShadowPacker::UnPackShadowInfo(Parcel &data, ShadowInfo &shadowInfo, bool isCross)
169 {
170     CALL_DEBUG_ENTER;
171     Media::PixelMap *rawPixelMap = nullptr;
172     if (isCross) {
173         FI_HILOGD("By DecodeTlv");
174         std::vector<uint8_t> pixelBuffer;
175         READUINT8VECTOR(data, pixelBuffer, ERR_INVALID_VALUE);
176         rawPixelMap = Media::PixelMap::DecodeTlv(pixelBuffer);
177     } else {
178         FI_HILOGD("By UnMarshalling");
179         rawPixelMap = OHOS::Media::PixelMap::Unmarshalling(data);
180     }
181     CHKPR(rawPixelMap, RET_ERR);
182     shadowInfo.pixelMap = std::shared_ptr<Media::PixelMap>(rawPixelMap);
183     CHKPR(shadowInfo.pixelMap, RET_ERR);
184     READINT32(data, shadowInfo.x, E_DEVICESTATUS_READ_PARCEL_ERROR);
185     READINT32(data, shadowInfo.y, E_DEVICESTATUS_READ_PARCEL_ERROR);
186     return RET_OK;
187 }
188 
CheckShadowInfo(const ShadowInfo & shadowInfo)189 int32_t ShadowPacker::CheckShadowInfo(const ShadowInfo &shadowInfo)
190 {
191     CHKPR(shadowInfo.pixelMap, RET_ERR);
192     if ((shadowInfo.x > 0) || (shadowInfo.y > 0) ||
193         (shadowInfo.x < -shadowInfo.pixelMap->GetWidth()) || (shadowInfo.y < -shadowInfo.pixelMap->GetHeight())) {
194         FI_HILOGE("Invalid parameter, shadowInfoX:%{private}d, shadowInfoY:%{private}d", shadowInfo.x, shadowInfo.y);
195         return RET_ERR;
196     }
197     return RET_OK;
198 }
199 
Marshalling(const SummaryMap & val,Parcel & parcel)200 int32_t SummaryPacker::Marshalling(const SummaryMap &val, Parcel &parcel)
201 {
202     WRITEINT32(parcel, static_cast<int32_t>(val.size()), ERR_INVALID_VALUE);
203     for (auto const &[k, v] : val) {
204         WRITESTRING(parcel, k, ERR_INVALID_VALUE);
205         WRITEINT64(parcel, v, ERR_INVALID_VALUE);
206     }
207     return RET_OK;
208 }
209 
UnMarshalling(Parcel & parcel,SummaryMap & val)210 int32_t SummaryPacker::UnMarshalling(Parcel &parcel, SummaryMap &val)
211 {
212     size_t readAbleSize = parcel.GetReadableBytes();
213     int32_t size = 0;
214     READINT32(parcel, size, E_DEVICESTATUS_READ_PARCEL_ERROR);
215     if (size < 0 || (static_cast<size_t>(size) > readAbleSize) || static_cast<size_t>(size) > val.max_size()) {
216         FI_HILOGE("Invalid size:%{public}d", size);
217         return RET_ERR;
218     }
219     for (int32_t i = 0; i < size; ++i) {
220         std::string key;
221         READSTRING(parcel, key, E_DEVICESTATUS_READ_PARCEL_ERROR);
222         READINT64(parcel, val[key], E_DEVICESTATUS_READ_PARCEL_ERROR);
223     }
224     return RET_OK;
225 }
226 
Marshalling(const ShadowOffset & shadowOffset,Parcel & parcel)227 int32_t ShadowOffsetPacker::Marshalling(const ShadowOffset&shadowOffset, Parcel &parcel)
228 {
229     WRITEINT32(parcel, shadowOffset.offsetX, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
230     WRITEINT32(parcel, shadowOffset.offsetY, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
231     WRITEINT32(parcel, shadowOffset.width, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
232     WRITEINT32(parcel, shadowOffset.height, E_DEVICESTATUS_WRITE_PARCEL_ERROR);
233     return RET_OK;
234 }
235 
UnMarshalling(Parcel & parcel,ShadowOffset & shadowOffset)236 int32_t ShadowOffsetPacker::UnMarshalling(Parcel &parcel, ShadowOffset&shadowOffset)
237 {
238     READINT32(parcel, shadowOffset.offsetX, E_DEVICESTATUS_READ_PARCEL_ERROR);
239     READINT32(parcel, shadowOffset.offsetY, E_DEVICESTATUS_READ_PARCEL_ERROR);
240     READINT32(parcel, shadowOffset.width, E_DEVICESTATUS_READ_PARCEL_ERROR);
241     READINT32(parcel, shadowOffset.height, E_DEVICESTATUS_READ_PARCEL_ERROR);
242     return RET_OK;
243 }
244 } // namespace DeviceStatus
245 } // namespace Msdp
246 } // namespace OHOS
247