1 /*
2  * Copyright (c) 2021-2022 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 "frameworks/bridge/codec/standard_codec_buffer_operator.h"
17 
18 #include <cstdint>
19 #include <map>
20 #include <set>
21 #include <string>
22 #include <type_traits>
23 
24 #include "base/log/log.h"
25 #include "bridge/codec/byte_buffer_operator.h"
26 #include "bridge/codec/codec_data.h"
27 
28 namespace OHOS::Ace::Framework {
29 namespace {
30 
31 template<class T>
ReadDataFromByteBuffer(const ByteBufferReader & buffer,CodecData & resultData)32 inline bool ReadDataFromByteBuffer(const ByteBufferReader& buffer, CodecData& resultData)
33 {
34     T data;
35     if (buffer.ReadData(data)) {
36         resultData = CodecData(std::move(data));
37         return true;
38     }
39     return false;
40 }
41 
42 } // namespace
43 
ReadType(BufferDataType & type)44 bool StandardCodecBufferReader::ReadType(BufferDataType& type)
45 {
46     uint8_t uint8Type = 0;
47     if (byteBufferReader_.ReadData(uint8Type)) {
48         type = static_cast<BufferDataType>(uint8Type);
49         return true;
50     }
51     return false;
52 }
53 
ReadMapSize(int32_t & data)54 bool StandardCodecBufferReader::ReadMapSize(int32_t& data)
55 {
56     BufferDataType type = BufferDataType::TYPE_NULL;
57     if (!ReadType(type)) {
58         LOGW("Read type failed");
59         return false;
60     }
61     if (type == BufferDataType::TYPE_MAP) {
62         byteBufferReader_.ReadData(data);
63         return true;
64     }
65     return false;
66 }
67 
ReadDataList(std::vector<CodecData> & resultDataList)68 bool StandardCodecBufferReader::ReadDataList(std::vector<CodecData>& resultDataList)
69 {
70     resultDataList.clear();
71     uint8_t size = 0;
72     if (!byteBufferReader_.ReadData(size)) {
73         LOGW("Failed to read size of data list");
74         return false;
75     }
76 
77     for (uint8_t idx = 0; idx < size; ++idx) {
78         CodecData data;
79         if (!ReadData(data)) {
80             LOGW("Failed to read data");
81             resultDataList.clear();
82             return false;
83         }
84         resultDataList.emplace_back(std::move(data));
85     }
86     return true;
87 }
88 
ReadData(CodecData & resultData)89 bool StandardCodecBufferReader::ReadData(CodecData& resultData)
90 {
91     BufferDataType type = BufferDataType::TYPE_NULL;
92     if (!ReadType(type)) {
93         LOGW("Read type failed");
94         return false;
95     }
96 
97     switch (type) {
98         case BufferDataType::TYPE_NULL:
99             resultData = CodecData();
100             return true;
101         case BufferDataType::TYPE_TRUE:
102             resultData = CodecData(true);
103             return true;
104         case BufferDataType::TYPE_FALSE:
105             resultData = CodecData(false);
106             return true;
107         case BufferDataType::TYPE_INT:
108             return ReadDataFromByteBuffer<int32_t>(byteBufferReader_, resultData);
109         case BufferDataType::TYPE_LONG:
110             return ReadDataFromByteBuffer<int64_t>(byteBufferReader_, resultData);
111         case BufferDataType::TYPE_DOUBLE:
112             return ReadDataFromByteBuffer<double>(byteBufferReader_, resultData);
113         case BufferDataType::TYPE_STRING:
114             return ReadDataFromByteBuffer<std::string>(byteBufferReader_, resultData);
115         case BufferDataType::TYPE_INT8_ARRAY:
116             return ReadDataFromByteBuffer<std::vector<int8_t>>(byteBufferReader_, resultData);
117         case BufferDataType::TYPE_INT16_ARRAY:
118             return ReadDataFromByteBuffer<std::vector<int16_t>>(byteBufferReader_, resultData);
119         case BufferDataType::TYPE_INT32_ARRAY:
120             return ReadDataFromByteBuffer<std::vector<int32_t>>(byteBufferReader_, resultData);
121         case BufferDataType::TYPE_MAP:
122             return ReadDataFromByteBuffer<std::map<std::string, std::string>>(byteBufferReader_, resultData);
123         case BufferDataType::TYPE_SET:
124             return ReadDataFromByteBuffer<std::set<std::string>>(byteBufferReader_, resultData);
125         case BufferDataType::TYPE_FUNCTION:
126             return ReadDataFromByteBuffer<int32_t>(byteBufferReader_, resultData);
127         case BufferDataType::TYPE_OBJECT:
128             return ReadDataFromByteBuffer<std::string>(byteBufferReader_, resultData);
129         default:
130             LOGW("Unknown type");
131             return false;
132     }
133 }
134 
WriteType(BufferDataType type)135 void StandardCodecBufferWriter::WriteType(BufferDataType type)
136 {
137     byteBufferWriter_.WriteData(static_cast<uint8_t>(type));
138 }
139 
WriteDataList(const std::vector<CodecData> & dataList)140 void StandardCodecBufferWriter::WriteDataList(const std::vector<CodecData>& dataList)
141 {
142     byteBufferWriter_.WriteData(static_cast<uint8_t>(dataList.size()));
143     for (const auto& data : dataList) {
144         WriteData(data);
145     }
146 }
147 
WriteData(const CodecData & data)148 void StandardCodecBufferWriter::WriteData(const CodecData& data)
149 {
150     WriteType(data.GetType());
151 
152     switch (data.GetType()) {
153         case BufferDataType::TYPE_INT:
154             byteBufferWriter_.WriteData(data.GetIntValue());
155             break;
156         case BufferDataType::TYPE_LONG:
157             byteBufferWriter_.WriteData(data.GetLongValue());
158             break;
159         case BufferDataType::TYPE_DOUBLE:
160             byteBufferWriter_.WriteData(data.GetDoubleValue());
161             break;
162         case BufferDataType::TYPE_STRING:
163             byteBufferWriter_.WriteData(data.GetStringValue());
164             break;
165         case BufferDataType::TYPE_INT8_ARRAY:
166             byteBufferWriter_.WriteData(data.GetInt8ArrayValue());
167             break;
168         case BufferDataType::TYPE_INT16_ARRAY:
169             byteBufferWriter_.WriteData(data.GetInt16ArrayValue());
170             break;
171         case BufferDataType::TYPE_INT32_ARRAY:
172             byteBufferWriter_.WriteData(data.GetInt32ArrayValue());
173             break;
174         case BufferDataType::TYPE_MAP:
175             byteBufferWriter_.WriteData(data.GetMapValue());
176             break;
177         case BufferDataType::TYPE_SET:
178             byteBufferWriter_.WriteData(data.GetSetValue());
179             break;
180         case BufferDataType::TYPE_FUNCTION:
181             byteBufferWriter_.WriteData(data.GetFunctionValue());
182             break;
183         case BufferDataType::TYPE_OBJECT:
184             byteBufferWriter_.WriteData(data.GetObjectValue());
185             break;
186         default:
187             break;
188     }
189 }
190 
191 } // namespace OHOS::Ace::Framework