1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file contains what would normally be standard_codec_serializer.cc,
6 // standard_message_codec.cc, and standard_method_codec.cc. They are grouped
7 // together to simplify use of the client wrapper, since the common case is
8 // that any client that needs one of these files needs all three.
9
10 #include "include/flutter/standard_message_codec.h"
11 #include "include/flutter/standard_method_codec.h"
12 #include "standard_codec_serializer.h"
13
14 #include <assert.h>
15 #include <cstring>
16 #include <iostream>
17 #include <map>
18 #include <string>
19 #include <vector>
20
21 namespace flutter {
22
23 // ===== standard_codec_serializer.h =====
24
25 namespace {
26
27 // The order/values here must match the constants in message_codecs.dart.
28 enum class EncodedType {
29 kNull = 0,
30 kTrue,
31 kFalse,
32 kInt32,
33 kInt64,
34 kLargeInt, // No longer used. If encountered, treat as kString.
35 kFloat64,
36 kString,
37 kUInt8List,
38 kInt32List,
39 kInt64List,
40 kFloat64List,
41 kList,
42 kMap,
43 };
44
45 // Returns the encoded type that should be written when serializing |value|.
EncodedTypeForValue(const EncodableValue & value)46 EncodedType EncodedTypeForValue(const EncodableValue& value) {
47 switch (value.type()) {
48 case EncodableValue::Type::kNull:
49 return EncodedType::kNull;
50 case EncodableValue::Type::kBool:
51 return value.BoolValue() ? EncodedType::kTrue : EncodedType::kFalse;
52 case EncodableValue::Type::kInt:
53 return EncodedType::kInt32;
54 case EncodableValue::Type::kLong:
55 return EncodedType::kInt64;
56 case EncodableValue::Type::kDouble:
57 return EncodedType::kFloat64;
58 case EncodableValue::Type::kString:
59 return EncodedType::kString;
60 case EncodableValue::Type::kByteList:
61 return EncodedType::kUInt8List;
62 case EncodableValue::Type::kIntList:
63 return EncodedType::kInt32List;
64 case EncodableValue::Type::kLongList:
65 return EncodedType::kInt64List;
66 case EncodableValue::Type::kDoubleList:
67 return EncodedType::kFloat64List;
68 case EncodableValue::Type::kList:
69 return EncodedType::kList;
70 case EncodableValue::Type::kMap:
71 return EncodedType::kMap;
72 }
73 assert(false);
74 return EncodedType::kNull;
75 }
76
77 } // namespace
78
79 StandardCodecSerializer::StandardCodecSerializer() = default;
80
81 StandardCodecSerializer::~StandardCodecSerializer() = default;
82
ReadValue(ByteBufferStreamReader * stream) const83 EncodableValue StandardCodecSerializer::ReadValue(
84 ByteBufferStreamReader* stream) const {
85 EncodedType type = static_cast<EncodedType>(stream->ReadByte());
86 ;
87 switch (type) {
88 case EncodedType::kNull:
89 return EncodableValue();
90 case EncodedType::kTrue:
91 return EncodableValue(true);
92 case EncodedType::kFalse:
93 return EncodableValue(false);
94 case EncodedType::kInt32: {
95 int32_t int_value = 0;
96 stream->ReadBytes(reinterpret_cast<uint8_t*>(&int_value), 4);
97 return EncodableValue(int_value);
98 }
99 case EncodedType::kInt64: {
100 int64_t long_value = 0;
101 stream->ReadBytes(reinterpret_cast<uint8_t*>(&long_value), 8);
102 return EncodableValue(long_value);
103 }
104 case EncodedType::kFloat64: {
105 double double_value = 0;
106 stream->ReadAlignment(8);
107 stream->ReadBytes(reinterpret_cast<uint8_t*>(&double_value), 8);
108 return EncodableValue(double_value);
109 }
110 case EncodedType::kLargeInt:
111 case EncodedType::kString: {
112 size_t size = ReadSize(stream);
113 std::string string_value;
114 string_value.resize(size);
115 stream->ReadBytes(reinterpret_cast<uint8_t*>(&string_value[0]), size);
116 return EncodableValue(string_value);
117 }
118 case EncodedType::kUInt8List:
119 return ReadVector<uint8_t>(stream);
120 case EncodedType::kInt32List:
121 return ReadVector<int32_t>(stream);
122 case EncodedType::kInt64List:
123 return ReadVector<int64_t>(stream);
124 case EncodedType::kFloat64List:
125 return ReadVector<double>(stream);
126 case EncodedType::kList: {
127 size_t length = ReadSize(stream);
128 EncodableList list_value;
129 list_value.reserve(length);
130 for (size_t i = 0; i < length; ++i) {
131 list_value.push_back(ReadValue(stream));
132 }
133 return EncodableValue(list_value);
134 }
135 case EncodedType::kMap: {
136 size_t length = ReadSize(stream);
137 EncodableMap map_value;
138 for (size_t i = 0; i < length; ++i) {
139 EncodableValue key = ReadValue(stream);
140 EncodableValue value = ReadValue(stream);
141 map_value.emplace(std::move(key), std::move(value));
142 }
143 return EncodableValue(map_value);
144 }
145 }
146 std::cerr << "Unknown type in StandardCodecSerializer::ReadValue: "
147 << static_cast<int>(type) << std::endl;
148 return EncodableValue();
149 }
150
WriteValue(const EncodableValue & value,ByteBufferStreamWriter * stream) const151 void StandardCodecSerializer::WriteValue(const EncodableValue& value,
152 ByteBufferStreamWriter* stream) const {
153 stream->WriteByte(static_cast<uint8_t>(EncodedTypeForValue(value)));
154 switch (value.type()) {
155 case EncodableValue::Type::kNull:
156 case EncodableValue::Type::kBool:
157 // Null and bool are encoded directly in the type.
158 break;
159 case EncodableValue::Type::kInt: {
160 int32_t int_value = value.IntValue();
161 stream->WriteBytes(reinterpret_cast<const uint8_t*>(&int_value), 4);
162 break;
163 }
164 case EncodableValue::Type::kLong: {
165 int64_t long_value = value.LongValue();
166 stream->WriteBytes(reinterpret_cast<const uint8_t*>(&long_value), 8);
167 break;
168 }
169 case EncodableValue::Type::kDouble: {
170 stream->WriteAlignment(8);
171 double double_value = value.DoubleValue();
172 stream->WriteBytes(reinterpret_cast<const uint8_t*>(&double_value), 8);
173 break;
174 }
175 case EncodableValue::Type::kString: {
176 const auto& string_value = value.StringValue();
177 size_t size = string_value.size();
178 WriteSize(size, stream);
179 stream->WriteBytes(reinterpret_cast<const uint8_t*>(string_value.data()),
180 size);
181 break;
182 }
183 case EncodableValue::Type::kByteList:
184 WriteVector(value.ByteListValue(), stream);
185 break;
186 case EncodableValue::Type::kIntList:
187 WriteVector(value.IntListValue(), stream);
188 break;
189 case EncodableValue::Type::kLongList:
190 WriteVector(value.LongListValue(), stream);
191 break;
192 case EncodableValue::Type::kDoubleList:
193 WriteVector(value.DoubleListValue(), stream);
194 break;
195 case EncodableValue::Type::kList:
196 WriteSize(value.ListValue().size(), stream);
197 for (const auto& item : value.ListValue()) {
198 WriteValue(item, stream);
199 }
200 break;
201 case EncodableValue::Type::kMap:
202 WriteSize(value.MapValue().size(), stream);
203 for (const auto& pair : value.MapValue()) {
204 WriteValue(pair.first, stream);
205 WriteValue(pair.second, stream);
206 }
207 break;
208 }
209 }
210
ReadSize(ByteBufferStreamReader * stream) const211 size_t StandardCodecSerializer::ReadSize(ByteBufferStreamReader* stream) const {
212 uint8_t byte = stream->ReadByte();
213 if (byte < 254) {
214 return byte;
215 } else if (byte == 254) {
216 uint16_t value;
217 stream->ReadBytes(reinterpret_cast<uint8_t*>(&value), 2);
218 return value;
219 } else {
220 uint32_t value;
221 stream->ReadBytes(reinterpret_cast<uint8_t*>(&value), 4);
222 return value;
223 }
224 }
225
WriteSize(size_t size,ByteBufferStreamWriter * stream) const226 void StandardCodecSerializer::WriteSize(size_t size,
227 ByteBufferStreamWriter* stream) const {
228 if (size < 254) {
229 stream->WriteByte(static_cast<uint8_t>(size));
230 } else if (size <= 0xffff) {
231 stream->WriteByte(254);
232 uint16_t value = static_cast<uint16_t>(size);
233 stream->WriteBytes(reinterpret_cast<uint8_t*>(&value), 2);
234 } else {
235 stream->WriteByte(255);
236 uint32_t value = static_cast<uint32_t>(size);
237 stream->WriteBytes(reinterpret_cast<uint8_t*>(&value), 4);
238 }
239 }
240
241 template <typename T>
ReadVector(ByteBufferStreamReader * stream) const242 EncodableValue StandardCodecSerializer::ReadVector(
243 ByteBufferStreamReader* stream) const {
244 size_t count = ReadSize(stream);
245 std::vector<T> vector;
246 vector.resize(count);
247 uint8_t type_size = static_cast<uint8_t>(sizeof(T));
248 if (type_size > 1) {
249 stream->ReadAlignment(type_size);
250 }
251 stream->ReadBytes(reinterpret_cast<uint8_t*>(vector.data()),
252 count * type_size);
253 return EncodableValue(vector);
254 }
255
256 template <typename T>
WriteVector(const std::vector<T> vector,ByteBufferStreamWriter * stream) const257 void StandardCodecSerializer::WriteVector(
258 const std::vector<T> vector,
259 ByteBufferStreamWriter* stream) const {
260 size_t count = vector.size();
261 WriteSize(count, stream);
262 uint8_t type_size = static_cast<uint8_t>(sizeof(T));
263 if (type_size > 1) {
264 stream->WriteAlignment(type_size);
265 }
266 stream->WriteBytes(reinterpret_cast<const uint8_t*>(vector.data()),
267 count * type_size);
268 }
269
270 // ===== standard_message_codec.h =====
271
272 // static
GetInstance()273 const StandardMessageCodec& StandardMessageCodec::GetInstance() {
274 static StandardMessageCodec sInstance;
275 return sInstance;
276 }
277
278 StandardMessageCodec::StandardMessageCodec() = default;
279
280 StandardMessageCodec::~StandardMessageCodec() = default;
281
DecodeMessageInternal(const uint8_t * binary_message,const size_t message_size) const282 std::unique_ptr<EncodableValue> StandardMessageCodec::DecodeMessageInternal(
283 const uint8_t* binary_message,
284 const size_t message_size) const {
285 StandardCodecSerializer serializer;
286 ByteBufferStreamReader stream(binary_message, message_size);
287 return std::make_unique<EncodableValue>(serializer.ReadValue(&stream));
288 }
289
290 std::unique_ptr<std::vector<uint8_t>>
EncodeMessageInternal(const EncodableValue & message) const291 StandardMessageCodec::EncodeMessageInternal(
292 const EncodableValue& message) const {
293 StandardCodecSerializer serializer;
294 auto encoded = std::make_unique<std::vector<uint8_t>>();
295 ByteBufferStreamWriter stream(encoded.get());
296 serializer.WriteValue(message, &stream);
297 return encoded;
298 }
299
300 // ===== standard_method_codec.h =====
301
302 // static
GetInstance()303 const StandardMethodCodec& StandardMethodCodec::GetInstance() {
304 static StandardMethodCodec sInstance;
305 return sInstance;
306 }
307
308 std::unique_ptr<MethodCall<EncodableValue>>
DecodeMethodCallInternal(const uint8_t * message,const size_t message_size) const309 StandardMethodCodec::DecodeMethodCallInternal(const uint8_t* message,
310 const size_t message_size) const {
311 StandardCodecSerializer serializer;
312 ByteBufferStreamReader stream(message, message_size);
313 EncodableValue method_name = serializer.ReadValue(&stream);
314 if (!method_name.IsString()) {
315 std::cerr << "Invalid method call; method name is not a string."
316 << std::endl;
317 return nullptr;
318 }
319 auto arguments =
320 std::make_unique<EncodableValue>(serializer.ReadValue(&stream));
321 return std::make_unique<MethodCall<EncodableValue>>(method_name.StringValue(),
322 std::move(arguments));
323 }
324
325 std::unique_ptr<std::vector<uint8_t>>
EncodeMethodCallInternal(const MethodCall<EncodableValue> & method_call) const326 StandardMethodCodec::EncodeMethodCallInternal(
327 const MethodCall<EncodableValue>& method_call) const {
328 StandardCodecSerializer serializer;
329 auto encoded = std::make_unique<std::vector<uint8_t>>();
330 ByteBufferStreamWriter stream(encoded.get());
331 serializer.WriteValue(EncodableValue(method_call.method_name()), &stream);
332 if (method_call.arguments()) {
333 serializer.WriteValue(*method_call.arguments(), &stream);
334 } else {
335 serializer.WriteValue(EncodableValue(), &stream);
336 }
337 return encoded;
338 }
339
340 std::unique_ptr<std::vector<uint8_t>>
EncodeSuccessEnvelopeInternal(const EncodableValue * result) const341 StandardMethodCodec::EncodeSuccessEnvelopeInternal(
342 const EncodableValue* result) const {
343 StandardCodecSerializer serializer;
344 auto encoded = std::make_unique<std::vector<uint8_t>>();
345 ByteBufferStreamWriter stream(encoded.get());
346 stream.WriteByte(0);
347 if (result) {
348 serializer.WriteValue(*result, &stream);
349 } else {
350 serializer.WriteValue(EncodableValue(), &stream);
351 }
352 return encoded;
353 }
354
355 std::unique_ptr<std::vector<uint8_t>>
EncodeErrorEnvelopeInternal(const std::string & error_code,const std::string & error_message,const EncodableValue * error_details) const356 StandardMethodCodec::EncodeErrorEnvelopeInternal(
357 const std::string& error_code,
358 const std::string& error_message,
359 const EncodableValue* error_details) const {
360 StandardCodecSerializer serializer;
361 auto encoded = std::make_unique<std::vector<uint8_t>>();
362 ByteBufferStreamWriter stream(encoded.get());
363 stream.WriteByte(1);
364 serializer.WriteValue(EncodableValue(error_code), &stream);
365 if (error_message.empty()) {
366 serializer.WriteValue(EncodableValue(), &stream);
367 } else {
368 serializer.WriteValue(EncodableValue(error_message), &stream);
369 }
370 if (error_details) {
371 serializer.WriteValue(*error_details, &stream);
372 } else {
373 serializer.WriteValue(EncodableValue(), &stream);
374 }
375 return encoded;
376 }
377
378 } // namespace flutter
379