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 "bluetooth_ble_advertiser_data.h"
17 #include "bluetooth_log.h"
18 #include "bt_uuid.h"
19
20 using OHOS::bluetooth::Uuid;
21 namespace OHOS {
22 namespace Bluetooth {
23 const int32_t BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN = 0x400;
Marshalling(Parcel &parcel) const24 bool BluetoothBleAdvertiserData::Marshalling(Parcel &parcel) const
25 {
26 if (!WriteServiceUuids(parcel)) {
27 return false;
28 }
29 if (!WriteManufacturerData(parcel)) {
30 return false;
31 }
32 if (!WriteServiceData(parcel)) {
33 return false;
34 }
35 if (!parcel.WriteUint8(advFlag_)) {
36 return false;
37 }
38 if (!parcel.WriteString(payload_)) {
39 return false;
40 }
41 if (!parcel.WriteBool(includeDeviceName_)) {
42 return false;
43 }
44 if (!parcel.WriteBool(includeTxPower_)) {
45 return false;
46 }
47 return true;
48 }
49
WriteToParcel(Parcel &parcel)50 bool BluetoothBleAdvertiserData::WriteToParcel(Parcel &parcel)
51 {
52 return Marshalling(parcel);
53 }
54
Unmarshalling(Parcel &parcel)55 BluetoothBleAdvertiserData *BluetoothBleAdvertiserData::Unmarshalling(Parcel &parcel)
56 {
57 BluetoothBleAdvertiserData *advertiserData = new BluetoothBleAdvertiserData();
58 if (advertiserData != nullptr && !advertiserData->ReadFromParcel(parcel)) {
59 delete advertiserData;
60 advertiserData = nullptr;
61 }
62 return advertiserData;
63 }
64
ReadFromParcel(Parcel &parcel)65 bool BluetoothBleAdvertiserData::ReadFromParcel(Parcel &parcel)
66 {
67 if (!ReadServiceUuids(serviceUuids_, parcel)) {
68 return false;
69 }
70 if (!ReadManufacturerData(manufacturerSpecificData_, parcel)) {
71 return false;
72 }
73 if (!ReadServiceData(serviceData_, parcel)) {
74 return false;
75 }
76 if (!parcel.ReadUint8(advFlag_)) {
77 return false;
78 }
79 if (!parcel.ReadString(payload_)) {
80 return false;
81 }
82 if (!parcel.ReadBool(includeDeviceName_)) {
83 return false;
84 }
85 if (!parcel.ReadBool(includeTxPower_)) {
86 return false;
87 }
88 return true;
89 }
90
WriteServiceUuids(Parcel &parcel) const91 bool BluetoothBleAdvertiserData::WriteServiceUuids(Parcel &parcel) const
92 {
93 if (!parcel.WriteInt32(serviceUuids_.size())) {
94 return false;
95 }
96 for (auto &serviceUuids : serviceUuids_) {
97 uint8_t buffer[Uuid::UUID128_BYTES_TYPE] = {0};
98 if (!serviceUuids.ConvertToBytesLE(buffer, Uuid::UUID128_BYTES_TYPE)) {
99 return false;
100 }
101 if (!parcel.WriteBuffer(static_cast<void *>(buffer), Uuid::UUID128_BYTES_TYPE)) {
102 return false;
103 }
104 }
105 return true;
106 }
107
ReadServiceUuids(std::vector<Uuid> &serviceUuids, Parcel &parcel)108 bool BluetoothBleAdvertiserData::ReadServiceUuids(std::vector<Uuid> &serviceUuids, Parcel &parcel)
109 {
110 int32_t serviceUuidSize = 0;
111 if (!parcel.ReadInt32(serviceUuidSize) || serviceUuidSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
112 HILOGE("read Parcelable size failed.");
113 return false;
114 }
115 for (int i = 0; i < serviceUuidSize; ++i) {
116 const uint8_t *buffer = parcel.ReadBuffer(static_cast<size_t>(Uuid::UUID128_BYTES_TYPE));
117 if (buffer == nullptr) {
118 HILOGE("ReadBuffer failed");
119 return false;
120 }
121 Uuid uuid = Uuid::ConvertFromBytesLE(buffer, static_cast<size_t>(Uuid::UUID128_BYTES_TYPE));
122 serviceUuids.push_back(uuid);
123 }
124 return true;
125 }
126
WriteManufacturerData(Parcel &parcel) const127 bool BluetoothBleAdvertiserData::WriteManufacturerData(Parcel &parcel) const
128 {
129 if (!parcel.WriteInt32(manufacturerSpecificData_.size())) {
130 return false;
131 }
132 for (auto &manufacturer : manufacturerSpecificData_) {
133 if (!parcel.WriteUint16(manufacturer.first)) {
134 return false;
135 }
136 if (!parcel.WriteString(manufacturer.second)) {
137 return false;
138 }
139 }
140 return true;
141 }
142
ReadManufacturerData(std::map<uint16_t, std::string> &manufacturerData, Parcel &parcel)143 bool BluetoothBleAdvertiserData::ReadManufacturerData(std::map<uint16_t, std::string> &manufacturerData, Parcel &parcel)
144 {
145 int manufacturerSize = 0;
146 if (!parcel.ReadInt32(manufacturerSize) || manufacturerSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
147 HILOGE("read Parcelable size failed.");
148 return false;
149 }
150 uint16_t manufacturerId;
151 std::string manufacturerDataValue;
152 for (int i = 0; i < manufacturerSize; ++i) {
153 if (!parcel.ReadUint16(manufacturerId)) {
154 return false;
155 }
156 if (!parcel.ReadString(manufacturerDataValue)) {
157 return false;
158 }
159 manufacturerData.emplace(manufacturerId, manufacturerDataValue);
160 }
161 return true;
162 }
163
WriteServiceData(Parcel &parcel) const164 bool BluetoothBleAdvertiserData::WriteServiceData(Parcel &parcel) const
165 {
166 if (!parcel.WriteInt32(serviceData_.size())) {
167 return false;
168 }
169 for (auto &service : serviceData_) {
170 if (!parcel.WriteUint32(service.first.ConvertTo32Bits())) {
171 return false;
172 }
173 if (!parcel.WriteString(service.second)) {
174 return false;
175 }
176 }
177 return true;
178 }
179
ReadServiceData(std::map<Uuid, std::string> &serviceData, Parcel &parcel)180 bool BluetoothBleAdvertiserData::ReadServiceData(std::map<Uuid, std::string> &serviceData, Parcel &parcel)
181 {
182 int serviceDataSize = 0;
183 if (!parcel.ReadInt32(serviceDataSize) || serviceDataSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
184 HILOGE("read Parcelable size failed.");
185 return false;
186 }
187 Uuid serviceDataId;
188 std::string serviceDataData;
189 for (int i = 0; i < serviceDataSize; ++i) {
190 uint32_t uuid;
191 if (parcel.ReadUint32(uuid)) {
192 serviceDataId = Uuid::ConvertFrom32Bits(uuid);
193 } else {
194 return false;
195 }
196 if (!parcel.ReadString(serviceDataData)) {
197 return false;
198 }
199 serviceData.emplace(serviceDataId, serviceDataData);
200 }
201 return true;
202 }
203 } // namespace Bluetooth
204 } // namespace OHOS
205