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
25namespace OHOS {
26namespace Msdp {
27namespace DeviceStatus {
28
29int32_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
56int32_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
83int32_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
101int32_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
123int32_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
144int32_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
168int32_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
189int32_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
200int32_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
210int32_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
227int32_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
236int32_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