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 "device_information_service.h"
17 #include <string>
18 #include "adapter_device_info.h"
19 #include "bt_def.h"
20 #include "class_creator.h"
21 #include "gatt/gatt_defines.h"
22 #include "log.h"
23
24 namespace OHOS {
25 namespace bluetooth {
26 const uint16_t DeviceInformationService::GATT_UUID_MANUFACTURER_NAME_STRING_CHAR = 0x2A29;
27 const uint16_t DeviceInformationService::GATT_UUID_MODEL_NUMBER_STRING_CHAR = 0x2A24;
28 const uint16_t DeviceInformationService::GATT_UUID_PNP_ID_CHAR = 0x2A50;
29 const uint16_t DeviceInformationService::GATT_UUID_IEEE_REGULATORY_CERTIFICATION_DATA_LIST_CHAR = 0x2A2A;
30 const uint16_t DeviceInformationService::GATT_UUID_SERIAL_NUMBER_STRING_CHAR = 0x2A25;
31 const uint16_t DeviceInformationService::GATT_UUID_SOFTWARE_REVISION_STRING_CHAR = 0x2A28;
32 const uint16_t DeviceInformationService::GATT_UUID_SYSTEM_ID_CHAR = 0x2A23;
33 const uint16_t DeviceInformationService::GATT_UUID_HARDWARE_REVISION_STRING_CHAR = 0x2A27;
34 const uint16_t DeviceInformationService::GATT_UUID_FIRMWARE_REVISION_STRING_CHAR = 0x2A26;
35
36 const std::string DeviceInformationService::DEFAULT_MANUFACTURER_NAME = "Hikey960";
37 const std::string DeviceInformationService::DEFAULT_MODEL_NUMBER = "960";
38 const std::string DeviceInformationService::DEFAULT_SERIAL_NUMBER = "AAAA-S032-4321";
39 const std::string DeviceInformationService::DEFAULT_HARDWARE_REVISION = "1.0.0";
40 const std::string DeviceInformationService::DEFAULT_FIRMWARE_REVISION = "1.0.0";
41 const std::string DeviceInformationService::DEFAULT_SOFTWARE_REVISION = "1.0.0";
42 const std::string DeviceInformationService::DEFAULT_SYSTEM_ID = "-";
43 const std::string DeviceInformationService::DEFAULT_IEEE_REGULATORY_CERTIFICATION_DATA_LIST = "-";
44 const std::string DeviceInformationService::DEFAULT_PNP_ID = "-";
45
DeviceInformationService(GattServerService & service)46 DeviceInformationService::DeviceInformationService(GattServerService &service)
47 : serverService_(service), serviceCallback_(std::make_shared<GattServerCallbackImpl>(*this))
48 {
49 AdapterDeviceInfo::GetInstance()->Load();
50 }
51
~DeviceInformationService()52 DeviceInformationService::~DeviceInformationService()
53 {}
54
55 class DeviceInformationService::GattServerCallbackImpl : public IGattServerCallback {
56 public:
OnCharacteristicReadRequest(const GattDevice & device,const Characteristic & characteristic)57 void OnCharacteristicReadRequest(const GattDevice &device, const Characteristic &characteristic) override
58 {
59 auto cIt = std::find_if(service_.instance_->characteristics_.begin(),
60 service_.instance_->characteristics_.end(),
61 [&characteristic](Characteristic &ccc) {
62 return ccc.handle_ == characteristic.handle_;
63 });
64
65 if (cIt != service_.instance_->characteristics_.end()) {
66 Characteristic result(characteristic.handle_, cIt->value_.get(), cIt->length_);
67 service_.serverService_.RespondCharacteristicRead(device, result, GattStatus::GATT_SUCCESS);
68 return;
69 }
70
71 Characteristic result(characteristic.handle_);
72 service_.serverService_.RespondCharacteristicRead(device, result, GattStatus::GATT_FAILURE);
73 }
74
OnCharacteristicReadByUuidRequest(const GattDevice & device,const Characteristic & characteristic)75 void OnCharacteristicReadByUuidRequest(const GattDevice &device, const Characteristic &characteristic) override
76 {
77 for (auto &ccc : service_.instance_->characteristics_) {
78 if (ccc.handle_ == characteristic.handle_) {
79 Characteristic result(characteristic.handle_, ccc.value_.get(), ccc.length_);
80 service_.serverService_.RespondCharacteristicReadByUuid(device, result, GattStatus::GATT_SUCCESS);
81 return;
82 }
83 }
84
85 Characteristic result(characteristic.handle_);
86 service_.serverService_.RespondCharacteristicReadByUuid(device, result, GattStatus::GATT_FAILURE);
87 }
88
OnConnectionStateChanged(const GattDevice & device,int ret,int state)89 void OnConnectionStateChanged(const GattDevice &device, int ret, int state) override
90 {}
91
GattServerCallbackImpl(const DeviceInformationService & service)92 explicit GattServerCallbackImpl(const DeviceInformationService &service) : service_(service)
93 {}
~GattServerCallbackImpl()94 ~GattServerCallbackImpl()
95 {}
96
97 private:
98 const DeviceInformationService &service_;
99 };
100
RegisterService()101 int DeviceInformationService::RegisterService()
102 {
103 appId_ = serverService_.RegisterApplicationSync(serviceCallback_);
104 if (appId_ < 0) {
105 return appId_;
106 }
107
108 instance_ = BuildService();
109 int result = serverService_.AddServiceSync(appId_, *instance_);
110 if (result != GattStatus::GATT_SUCCESS) {
111 LOG_WARN("%{public}s:%{public}d:%{public}s : Add GAS Failed! ret: %{public}d", __FILE__, __LINE__, __FUNCTION__, result);
112 }
113
114 return result;
115 }
116
DeregisterService() const117 void DeviceInformationService::DeregisterService() const
118 {
119 LOG_INFO("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
120 serverService_.DeregisterApplicationSync(appId_);
121 }
122
RegisterSDP()123 int DeviceInformationService::RegisterSDP()
124 {
125 if (instance_ == nullptr) {
126 return GattStatus::REQUEST_NOT_SUPPORT;
127 }
128
129 sdpRegister_.reset(ClassCreator<DiServiceOverBredr>::NewInstance("DiServiceOverBredr"));
130 if (sdpRegister_ != nullptr) {
131 static_cast<DiServiceOverBredrInterface *>(sdpRegister_.get())
132 ->RegisterSDP(instance_->startHandle_, instance_->endHandle_);
133 }
134
135 LOG_DEBUG("[DeviceInformationService]::%{public}s", __FUNCTION__);
136
137 return GattStatus::GATT_SUCCESS;
138 }
139
DeregisterSDP() const140 void DeviceInformationService::DeregisterSDP() const
141 {
142 LOG_INFO("%{public}s:%{public}d:%{public}s", __FILE__, __LINE__, __FUNCTION__);
143 if (sdpRegister_ != nullptr) {
144 static_cast<DiServiceOverBredrInterface *>(sdpRegister_.get())->DeregisterSDP();
145 }
146 }
147
BuildService()148 std::unique_ptr<Service> DeviceInformationService::BuildService()
149 {
150 std::unique_ptr<Service> svc =
151 std::make_unique<Service>(Uuid::ConvertFrom16Bits(UUID_DEVICE_INFORMATION_SERVICE), 0, 0, 0);
152 svc->isPrimary_ = true;
153
154 std::string value = GetManufactureName();
155 svc->characteristics_.push_back(
156 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_MANUFACTURER_NAME_STRING_CHAR),
157 0,
158 CHARACTERISTIC_PROPERTIE_READ,
159 (int)GattPermissionService::READABLE,
160 (uint8_t *)value.c_str(),
161 value.size()));
162
163 value = GetModelNumber();
164 svc->characteristics_.push_back(
165 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_MODEL_NUMBER_STRING_CHAR),
166 0,
167 CHARACTERISTIC_PROPERTIE_READ,
168 (int)GattPermissionService::READABLE,
169 (uint8_t *)value.c_str(),
170 value.size()));
171
172 value = GetPnpId();
173 svc->characteristics_.push_back(Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_PNP_ID_CHAR),
174 0,
175 CHARACTERISTIC_PROPERTIE_READ,
176 (int)GattPermissionService::READABLE,
177 (uint8_t *)value.c_str(),
178 value.size()));
179
180 value = GetIEEEInfo();
181 svc->characteristics_.push_back(
182 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_IEEE_REGULATORY_CERTIFICATION_DATA_LIST_CHAR),
183 0,
184 CHARACTERISTIC_PROPERTIE_READ,
185 (int)GattPermissionService::READABLE,
186 (uint8_t *)value.c_str(),
187 value.size()));
188
189 value = GetSerialNumber();
190 svc->characteristics_.push_back(
191 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_SERIAL_NUMBER_STRING_CHAR),
192 0,
193 CHARACTERISTIC_PROPERTIE_READ,
194 (int)GattPermissionService::READABLE,
195 (uint8_t *)value.c_str(),
196 value.size()));
197
198 value = GetSoftwareRevision();
199 svc->characteristics_.push_back(
200 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_SOFTWARE_REVISION_STRING_CHAR),
201 0,
202 CHARACTERISTIC_PROPERTIE_READ,
203 (int)GattPermissionService::READABLE,
204 (uint8_t *)value.c_str(),
205 value.size()));
206
207 value = GetSystemId();
208 svc->characteristics_.push_back(Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_SYSTEM_ID_CHAR),
209 0,
210 CHARACTERISTIC_PROPERTIE_READ,
211 (int)GattPermissionService::READABLE,
212 (uint8_t *)value.c_str(),
213 value.size()));
214
215 value = GetHardwareRevision();
216 svc->characteristics_.push_back(
217 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_HARDWARE_REVISION_STRING_CHAR),
218 0,
219 CHARACTERISTIC_PROPERTIE_READ,
220 (int)GattPermissionService::READABLE,
221 (uint8_t *)value.c_str(),
222 value.size()));
223
224 value = GetFirmwareRevision();
225 svc->characteristics_.push_back(
226 Characteristic(Uuid::ConvertFrom16Bits(GATT_UUID_FIRMWARE_REVISION_STRING_CHAR),
227 0,
228 CHARACTERISTIC_PROPERTIE_READ,
229 (int)GattPermissionService::READABLE,
230 (uint8_t *)value.c_str(),
231 value.size()));
232
233 return svc;
234 }
235
GetSystemId()236 std::string DeviceInformationService::GetSystemId()
237 {
238 std::string result = DEFAULT_SYSTEM_ID;
239 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_SYSYTEM_ID, result);
240 return result;
241 }
242
GetPnpId()243 std::string DeviceInformationService::GetPnpId()
244 {
245 std::string result = DEFAULT_PNP_ID;
246 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_PNP_ID, result);
247 return result;
248 }
249
GetIEEEInfo()250 std::string DeviceInformationService::GetIEEEInfo()
251 {
252 std::string result = DEFAULT_IEEE_REGULATORY_CERTIFICATION_DATA_LIST;
253 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_IEEE_INFO, result);
254 return result;
255 }
256
GetManufactureName()257 std::string DeviceInformationService::GetManufactureName()
258 {
259 std::string result = DEFAULT_MANUFACTURER_NAME;
260 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_MANUFACTURER_NAME, result);
261 return result;
262 }
263
GetModelNumber()264 std::string DeviceInformationService::GetModelNumber()
265 {
266 std::string result = DEFAULT_MODEL_NUMBER;
267 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_MODEL_NUMBER, result);
268 return result;
269 }
270
GetSerialNumber()271 std::string DeviceInformationService::GetSerialNumber()
272 {
273 std::string result = DEFAULT_SERIAL_NUMBER;
274 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_SERIAL_NUMBER, result);
275 return result;
276 }
277
GetHardwareRevision()278 std::string DeviceInformationService::GetHardwareRevision()
279 {
280 std::string result = DEFAULT_HARDWARE_REVISION;
281 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_HARDWARE_REVISION, result);
282 return result;
283 }
284
GetFirmwareRevision()285 std::string DeviceInformationService::GetFirmwareRevision()
286 {
287 std::string result = DEFAULT_FIRMWARE_REVISION;
288 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_FIRMWARE_REVISION, result);
289 return result;
290 }
291
GetSoftwareRevision()292 std::string DeviceInformationService::GetSoftwareRevision()
293 {
294 std::string result = DEFAULT_SOFTWARE_REVISION;
295 AdapterDeviceInfo::GetInstance()->GetValue(SECTION_BLE, PROPERTY_SOFTWARE_REVISION, result);
296 return result;
297 }
298 } // namespace bluetooth
299 } // namespace OHOS