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