1 /*
2  * Copyright (C) 2021 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_scan_result.h"
17 #include "bluetooth_log.h"
18 
19 namespace OHOS {
20 namespace Bluetooth {
21 const int32_t BLE_SCAN_READ_DATA_SIZE_MAX_LEN = 0x400;
Marshalling(Parcel &parcel) const22 bool BluetoothBleScanResult::Marshalling(Parcel &parcel) const
23 {
24     if (!WirteServiceUuidsToParcel(parcel)) {
25         return false;
26     }
27     if (!WirteManufacturerDataToParcel(parcel)) {
28         return false;
29     }
30     if (!WirteServiceDataToParcel(parcel)) {
31         return false;
32     }
33     if (!parcel.WriteString(addr_.GetAddress())) {
34         return false;
35     }
36     if (!parcel.WriteInt8(rssi_)) {
37         return false;
38     }
39     if (!parcel.WriteBool(connectable_)) {
40         return false;
41     }
42     if (!parcel.WriteUint8(advertiseFlag_)) {
43         return false;
44     }
45     if (!parcel.WriteString(payload_)) {
46         return false;
47     }
48     if (!parcel.WriteString(name_)) {
49         return false;
50     }
51     if (!parcel.WriteUint16(eventType_)) {
52         return false;
53     }
54     return true;
55 }
56 
Unmarshalling(Parcel &parcel)57 BluetoothBleScanResult *BluetoothBleScanResult::Unmarshalling(Parcel &parcel)
58 {
59     BluetoothBleScanResult *settings = new BluetoothBleScanResult();
60     if (settings != nullptr && !settings->ReadFromParcel(parcel)) {
61         delete settings;
62         settings = nullptr;
63     }
64     return settings;
65 }
66 
WriteToParcel(Parcel &parcel)67 bool BluetoothBleScanResult::WriteToParcel(Parcel &parcel)
68 {
69     return Marshalling(parcel);
70 }
71 
ReadFromParcel(Parcel &parcel)72 bool BluetoothBleScanResult::ReadFromParcel(Parcel &parcel)
73 {
74     if (!ReadServiceUuidsFromParcel(parcel)) {
75         return false;
76     }
77     if (!ReadManufacturerDataFromParcel(parcel)) {
78         return false;
79     }
80     if (!ReadServiceDataFromParcel(parcel)) {
81         return false;
82     }
83     std::string address = "";
84     if (parcel.ReadString(address)) {
85         addr_ = bluetooth::RawAddress(address);
86     } else {
87         return false;
88     }
89     if (!parcel.ReadInt8(rssi_)) {
90         return false;
91     }
92     if (!parcel.ReadBool(connectable_)) {
93         return false;
94     }
95     if (!parcel.ReadUint8(advertiseFlag_)) {
96         return false;
97     }
98     if (!parcel.ReadString(payload_)) {
99         return false;
100     }
101     if (!parcel.ReadString(name_)) {
102         return false;
103     }
104     if (!parcel.ReadUint16(eventType_)) {
105         return false;
106     }
107     return true;
108 }
109 
WirteServiceUuidsToParcel(Parcel &parcel) const110 bool BluetoothBleScanResult::WirteServiceUuidsToParcel(Parcel &parcel) const
111 {
112     if (!parcel.WriteInt32(serviceUuids_.size())) {
113         return false;
114     }
115     for (auto iter : serviceUuids_) {
116         if (!parcel.WriteUint32(iter.ConvertTo32Bits())) {
117             return false;
118         }
119     }
120     return true;
121 }
122 
ReadServiceUuidsFromParcel(Parcel &parcel)123 bool BluetoothBleScanResult::ReadServiceUuidsFromParcel(Parcel &parcel)
124 {
125     int32_t uuidSize = 0;
126     if (!parcel.ReadInt32(uuidSize) || uuidSize > BLE_SCAN_READ_DATA_SIZE_MAX_LEN) {
127         HILOGE("read Parcelable size failed.");
128         return false;
129     }
130     for (int i = 0; i < uuidSize; ++i) {
131         uint32_t uuid;
132         if (parcel.ReadUint32(uuid)) {
133             serviceUuids_.push_back(bluetooth::Uuid::ConvertFrom32Bits(uuid));
134         } else {
135             return false;
136         }
137     }
138     return true;
139 }
140 
WirteManufacturerDataToParcel(Parcel &parcel) const141 bool BluetoothBleScanResult::WirteManufacturerDataToParcel(Parcel &parcel) const
142 {
143     if (!parcel.WriteInt32(manufacturerSpecificData_.size())) {
144         return false;
145     }
146     for (auto iter = manufacturerSpecificData_.begin(); iter != manufacturerSpecificData_.end(); ++iter) {
147         if (!parcel.WriteUint16(iter->first)) {
148             return false;
149         }
150         if (!parcel.WriteString(iter->second)) {
151             return false;
152         }
153     }
154     return true;
155 }
156 
ReadManufacturerDataFromParcel(Parcel &parcel)157 bool BluetoothBleScanResult::ReadManufacturerDataFromParcel(Parcel &parcel)
158 {
159     int32_t manuSize = 0;
160     if (!parcel.ReadInt32(manuSize) || manuSize > BLE_SCAN_READ_DATA_SIZE_MAX_LEN) {
161         HILOGE("read Parcelable size failed.");
162         return false;
163     }
164     for (int i = 0; i < manuSize; i++) {
165         uint16_t manufacturerId = 0;
166         std::string manufacturedData;
167         if (!parcel.ReadUint16(manufacturerId)) {
168             return false;
169         }
170         if (!parcel.ReadString(manufacturedData)) {
171             return false;
172         }
173         manufacturerSpecificData_.emplace(manufacturerId, manufacturedData);
174     }
175     return true;
176 }
177 
WirteServiceDataToParcel(Parcel &parcel) const178 bool BluetoothBleScanResult::WirteServiceDataToParcel(Parcel &parcel) const
179 {
180     if (!parcel.WriteInt32(serviceData_.size())) {
181         return false;
182     }
183     for (auto iter = serviceData_.begin(); iter != serviceData_.end(); ++iter) {
184         if (!parcel.WriteUint32(iter->first.ConvertTo32Bits())) {
185             return false;
186         }
187         if (!parcel.WriteString(iter->second)) {
188             return false;
189         }
190     }
191     return true;
192 }
193 
ReadServiceDataFromParcel(Parcel &parcel)194 bool BluetoothBleScanResult::ReadServiceDataFromParcel(Parcel &parcel)
195 {
196     int32_t serviceDataSize = 0;
197     if (!parcel.ReadInt32(serviceDataSize) || serviceDataSize > BLE_SCAN_READ_DATA_SIZE_MAX_LEN) {
198         HILOGE("read Parcelable size failed.");
199         return false;
200     }
201     for (int i = 0; i < serviceDataSize; i++) {
202         uint32_t serviceId;
203         std::string serviceData;
204         if (!parcel.ReadUint32(serviceId)) {
205             return false;
206         }
207         if (!parcel.ReadString(serviceData)) {
208             return false;
209         }
210         serviceData_.emplace(bluetooth::Uuid::ConvertFrom32Bits(serviceId), serviceData);
211     }
212     return true;
213 }
214 }  // namespace Bluetooth
215 }  // namespace OHOS