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