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