1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2024. All rights reserved.
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 #include "usb_accessory_manager.h"
16
17 #include <iostream>
18 #include <functional>
19 #include <chrono>
20 #include <sstream>
21 #include <iomanip>
22 #include <hdf_base.h>
23
24 #include "common_event_data.h"
25 #include "common_event_manager.h"
26 #include "common_event_support.h"
27 #include "hisysevent.h"
28 #include "usb_errors.h"
29 #include "usb_srv_support.h"
30 #include "usbd_type.h"
31 #include "cJSON.h"
32 using namespace OHOS::AAFwk;
33 using namespace OHOS::EventFwk;
34 using namespace OHOS::HiviewDFX;
35 using namespace OHOS::HDI::Usb::V1_0;
36 using namespace OHOS::HDI::Usb::V1_2;
37
38 namespace OHOS {
39 namespace USB {
40 constexpr int32_t ACCESSORY_INFO_SIZE = 5;
41 constexpr uint32_t ACCESSORY_EXTRA_INDEX = 5;
42 constexpr uint32_t FUN_ACCESSORY = 1 << 11;
43 constexpr int32_t NUM_OF_SERAIL_BIT = 16;
44 constexpr uint32_t DELAY_ACC_INTERVAL = 10 * 1000;
45 constexpr uint32_t ANTI_SHAKE_INTERVAL = 1 * 1000;
46 constexpr int32_t ACCESSORY_IS_BUSY = -16;
47 const int INDEX_FIRST = 0;
48 const int INDEX_SECOND = 1;
49 const int INDEX_THIRD = 2;
50 const int INDEX_FORTH = 3;
51 const int INDEX_FIFTH = 4;
52 const uint32_t OFFSET2 = 2;
53 const uint32_t OFFSET4 = 4;
54 const uint32_t OFFSET6 = 6;
55 const std::string BASE_64_CHARS =
56 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
57 "abcdefghijklmnopqrstuvwxyz"
58 "0123456789+/";
59
60 // LCOV_EXCL_START
UsbAccessoryManager()61 UsbAccessoryManager::UsbAccessoryManager()
62 {
63 USB_HILOGI(MODULE_USB_SERVICE, "UsbAccessoryManager::Init start");
64 #ifndef USB_MANAGER_V2_0
65 usbdImpl_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
66 if (usbdImpl_ == nullptr) {
67 USB_HILOGE(MODULE_USB_SERVICE, "UsbDeviceManager::Get inteface failed");
68 }
69 #endif // USB_MANAGER_V2_0
70 uint32_t ret = antiShakeDelayTimer_.Setup();
71 if (ret != UEC_OK) {
72 USB_HILOGE(MODULE_USB_SERVICE, "set up antiShakeDelayTimer_ failed %{public}u", ret);
73 return;
74 }
75 ret = accDelayTimer_.Setup();
76 if (ret != UEC_OK) {
77 USB_HILOGE(MODULE_USB_SERVICE, "set up accDelayTimer_ failed %{public}u", ret);
78 return;
79 }
80 }
81
~UsbAccessoryManager()82 UsbAccessoryManager::~UsbAccessoryManager()
83 {
84 accDelayTimer_.Shutdown();
85 antiShakeDelayTimer_.Shutdown();
86 }
87
88 #ifdef USB_MANAGER_V2_0
InitUsbAccessoryInterface()89 bool UsbAccessoryManager::InitUsbAccessoryInterface()
90 {
91 USB_HILOGI(MODULE_USB_SERVICE, "UsbAccessoryManager::InitUsbAccessoryInterface start");
92 usbDeviceInterface_ = HDI::Usb::V2_0::IUsbDeviceInterface::Get();
93 if (usbDeviceInterface_ == nullptr) {
94 USB_HILOGE(MODULE_USB_SERVICE, "UsbAccessoryManager:: Get inteface failed");
95 return false;
96 }
97 return true;
98 }
99 #endif // USB_MANAGER_V2_0
100
GetAccessoryInfo(std::vector<std::string> & accessorys)101 void UsbAccessoryManager::GetAccessoryInfo(std::vector<std::string> &accessorys)
102 {
103 #ifdef USB_MANAGER_V2_0
104 if (usbDeviceInterface_ == nullptr) {
105 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbDeviceInterface_ is nullptr.");
106 return;
107 }
108 usbDeviceInterface_->GetAccessoryInfo(accessorys);
109 #else
110 if (usbdImpl_ == nullptr) {
111 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbdImpl_ is nullptr.");
112 return;
113 }
114 usbdImpl_->GetAccessoryInfo(accessorys);
115 #endif // USB_MANAGER_V2_0
116 }
117
SetCurrentFunctions(int32_t funcs)118 int32_t UsbAccessoryManager::SetCurrentFunctions(int32_t funcs)
119 {
120 #ifdef USB_MANAGER_V2_0
121 if (usbDeviceInterface_ == nullptr) {
122 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbDeviceInterface_ is nullptr.");
123 return UEC_SERVICE_INVALID_VALUE;
124 }
125 return usbDeviceInterface_->SetCurrentFunctions(funcs);
126 #else
127 if (usbdImpl_ == nullptr) {
128 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbdImpl_ is nullptr.");
129 return UEC_SERVICE_INVALID_VALUE;
130 }
131 return usbdImpl_->SetCurrentFunctions(funcs);
132 #endif // USB_MANAGER_V2_0
133 }
134
GetCurrentFunctions(int32_t & funcs)135 int32_t UsbAccessoryManager::GetCurrentFunctions(int32_t &funcs)
136 {
137 #ifdef USB_MANAGER_V2_0
138 if (usbDeviceInterface_ == nullptr) {
139 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbDeviceInterface_ is nullptr.");
140 return UEC_SERVICE_INVALID_VALUE;
141 }
142 return usbDeviceInterface_->GetCurrentFunctions(funcs);
143 #else
144 if (usbdImpl_ == nullptr) {
145 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbdImpl_ is nullptr.");
146 return UEC_SERVICE_INVALID_VALUE;
147 }
148 return usbdImpl_->GetCurrentFunctions(funcs);
149 #endif // USB_MANAGER_V2_0
150 }
151
SetUsbd(const sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> usbd)152 int32_t UsbAccessoryManager::SetUsbd(const sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> usbd)
153 {
154 if (usbd == nullptr) {
155 USB_HILOGE(MODULE_USB_SERVICE, "UsbAccessoryManager usbd is nullptr");
156 return UEC_SERVICE_INVALID_VALUE;
157 }
158 usbdImpl_ = usbd;
159 return UEC_OK;
160 }
161
GetAccessoryList(const std::string & bundleName,std::vector<USBAccessory> & accessoryList)162 void UsbAccessoryManager::GetAccessoryList(const std::string &bundleName,
163 std::vector<USBAccessory> &accessoryList)
164 {
165 if (accStatus_ == ACC_START) {
166 USBAccessory access = this->accessory;
167 access.SetSerialNumber(bundleName + this->accessory.GetSerialNumber());
168 accessoryList.push_back(access);
169 }
170 return;
171 }
172
OpenAccessory(int32_t & fd)173 int32_t UsbAccessoryManager::OpenAccessory(int32_t &fd)
174 {
175 int32_t ret = UEC_INTERFACE_INVALID_VALUE;
176 #ifdef USB_MANAGER_V2_0
177 if (usbDeviceInterface_ == nullptr) {
178 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbDeviceInterface_ is nullptr.");
179 return UEC_SERVICE_INVALID_VALUE;
180 }
181 ret = usbDeviceInterface_->OpenAccessory(fd);
182 #else
183 if (usbdImpl_ == nullptr) {
184 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbdImpl_ is nullptr.");
185 return UEC_SERVICE_INVALID_VALUE;
186 }
187 ret = usbdImpl_->OpenAccessory(fd);
188 #endif // USB_MANAGER_V2_0
189 if (ret == UEC_OK) {
190 accFd_ = fd;
191 return ret;
192 } else if (ret == ACCESSORY_IS_BUSY) {
193 return UEC_SERVICE_ACCESSORY_REOPEN;
194 }
195 return UEC_SERVICE_ACCESSORY_OPEN_NATIVE_NODE_FAILED;
196 }
197
CloseAccessory(int32_t fd)198 int32_t UsbAccessoryManager::CloseAccessory(int32_t fd)
199 {
200 int32_t ret = UEC_INTERFACE_INVALID_VALUE;
201 #ifdef USB_MANAGER_V2_0
202 if (usbDeviceInterface_ == nullptr) {
203 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbDeviceInterface_ is nullptr.");
204 return UEC_SERVICE_INVALID_VALUE;
205 }
206 ret = usbDeviceInterface_->CloseAccessory(accFd_);
207 #else
208 if (usbdImpl_ == nullptr) {
209 USB_HILOGE(MODULE_USB_INNERKIT, "UsbAccessoryManager usbdImpl_ is nullptr.");
210 return UEC_SERVICE_INVALID_VALUE;
211 }
212 ret = usbdImpl_->CloseAccessory(accFd_);
213 #endif // USB_MANAGER_V2_0
214 if (ret != UEC_OK) {
215 USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s, close ret: %{public}d, fd: %{public}d.", __func__, ret, fd);
216 return ret;
217 }
218 accFd_ = 0;
219 return ret;
220 }
221
ProcessAccessoryStart(int32_t curFunc,int32_t curAccStatus)222 int32_t UsbAccessoryManager::ProcessAccessoryStart(int32_t curFunc, int32_t curAccStatus)
223 {
224 uint32_t curFuncUint = static_cast<uint32_t>(curFunc);
225 if ((curFuncUint & FUN_ACCESSORY) != 0 && accStatus_ != ACC_START) {
226 this->accStatus_ = ACC_START;
227 std::vector<std::string> accessorys;
228 GetAccessoryInfo(accessorys);
229 this->accessory.SetAccessory(accessorys);
230 std::string hashSerial = SerialValueHash(this->accessory.GetSerialNumber());
231 this->accessory.SetSerialNumber(hashSerial);
232 Want want;
233 want.SetAction(CommonEventSupport::COMMON_EVENT_USB_ACCESSORY_ATTACHED);
234 CommonEventData data(want);
235 data.SetData(this->accessory.GetJsonString().c_str());
236 CommonEventPublishInfo publishInfo;
237 USB_HILOGI(MODULE_SERVICE, "send accessory attached broadcast device:%{public}s",
238 this->accessory.GetJsonString().c_str());
239 return CommonEventManager::PublishCommonEvent(data, publishInfo);
240 } else if ((curFuncUint & FUN_ACCESSORY) == 0 && curAccStatus == ACC_CONFIGURING) {
241 int32_t ret = SetCurrentFunctions(FUN_ACCESSORY);
242 if (ret != UEC_OK) {
243 USB_HILOGE(MODULE_SERVICE, "curFunc %{public}d curAccStatus:%{public}u, set func ret: %{public}d",
244 curFuncUint, curAccStatus, ret);
245 return ret;
246 }
247 lastDeviceFunc_ = static_cast<int32_t>(curFuncUint);
248 auto task = [&]() {
249 this->accStatus_ = ACC_STOP;
250 int32_t ret = SetCurrentFunctions(this->lastDeviceFunc_);
251 if (ret != UEC_OK) {
252 USB_HILOGW(MODULE_SERVICE, "set old func: %{public}d ret: %{public}d", this->lastDeviceFunc_, ret);
253 }
254 return;
255 };
256 accDelayTimerId_ = accDelayTimer_.Register(task, DELAY_ACC_INTERVAL, true);
257 this->accStatus_ = ACC_CONFIGURING;
258 } else {
259 USB_HILOGD(MODULE_SERVICE, "curFunc %{public}u curAccStatus:%{public}d not necessary",
260 curFuncUint, curAccStatus);
261 }
262 return UEC_OK;
263 }
264
ProcessAccessoryStop(int32_t curFunc,int32_t curAccStatus)265 int32_t UsbAccessoryManager::ProcessAccessoryStop(int32_t curFunc, int32_t curAccStatus)
266 {
267 uint32_t curFuncUint = static_cast<uint32_t>(curFunc);
268 if ((curFuncUint & FUN_ACCESSORY) != 0 && accStatus_ == ACC_START) {
269 accStatus_ = ACC_STOP;
270 int32_t ret = SetCurrentFunctions(lastDeviceFunc_);
271 if (ret != UEC_OK) {
272 USB_HILOGW(MODULE_SERVICE, "setFunc %{public}d curAccStatus:%{public}d, set func ret: %{public}d",
273 lastDeviceFunc_, curAccStatus, ret);
274 }
275 curDeviceFunc_ = lastDeviceFunc_;
276 Want want;
277 want.SetAction(CommonEventSupport::COMMON_EVENT_USB_ACCESSORY_DETACHED);
278 CommonEventData data(want);
279 data.SetData(this->accessory.GetJsonString().c_str());
280 CommonEventPublishInfo publishInfo;
281 USB_HILOGI(MODULE_SERVICE, "send accessory detached broadcast device:%{public}s",
282 this->accessory.GetJsonString().c_str());
283 return CommonEventManager::PublishCommonEvent(data, publishInfo);
284 } else {
285 USB_HILOGD(MODULE_SERVICE, "curFunc %{public}u curAccStatus:%{public}d not necessary",
286 curFuncUint, curAccStatus);
287 }
288 return UEC_OK;
289 }
290
ProcessAccessorySend()291 int32_t UsbAccessoryManager::ProcessAccessorySend()
292 {
293 this->accStatus_ = ACC_SEND;
294 std::vector<std::string> accessorys;
295 GetAccessoryInfo(accessorys);
296 this->accessory.SetAccessory(accessorys);
297 std::string extraInfo;
298 if (accessorys.size() > ACCESSORY_INFO_SIZE &&
299 ACCESSORY_EXTRA_INDEX < accessorys.size() && !accessorys[ACCESSORY_EXTRA_INDEX].empty()) {
300 if (base64Map_.empty()) {
301 InitBase64Map();
302 }
303 std::string extraEcode = accessorys[ACCESSORY_EXTRA_INDEX];
304 USB_HILOGE(MODULE_USB_SERVICE, "extraEcode, length: %{public}zu, extraData: %{public}s",
305 extraEcode.length(), extraEcode.c_str());
306 std::vector<uint8_t> extraData = Base64Decode(extraEcode);
307 cJSON *root = cJSON_CreateArray();
308 for (uint8_t value : extraData) {
309 cJSON_AddItemToArray(root, cJSON_CreateNumber(value));
310 }
311 char *pExtraJson = cJSON_PrintUnformatted(root);
312 cJSON_Delete(root);
313 if (!pExtraJson) {
314 USB_HILOGE(MODULE_USB_SERVICE, "print json error.");
315 return UEC_SERVICE_INVALID_VALUE;
316 }
317 extraInfo = pExtraJson;
318 cJSON_free(pExtraJson);
319 pExtraJson = nullptr;
320 }
321
322 USBAccessory extraAcces;
323 extraAcces.SetDescription(extraInfo);
324 Want want;
325 want.SetAction(CommonEventSupport::COMMON_EVENT_USB_ACCESSORY_ATTACHED);
326 CommonEventData data(want);
327 data.SetData(extraAcces.GetJsonString().c_str());
328 CommonEventPublishInfo publishInfo;
329 USB_HILOGI(MODULE_SERVICE, "send accessory attached broadcast device:%{public}s",
330 extraAcces.GetJsonString().c_str());
331 CommonEventManager::PublishCommonEvent(data, publishInfo);
332 return UEC_OK;
333 }
334
HandleEvent(int32_t status,bool delayProcess)335 void UsbAccessoryManager::HandleEvent(int32_t status, bool delayProcess)
336 {
337 #ifdef USB_MANAGER_V2_0
338 if (usbDeviceInterface_ == nullptr) {
339 USB_HILOGE(MODULE_USB_SERVICE, "UsbAccessoryManager::usbDeviceInterface_ is nullptr");
340 return;
341 }
342 #else
343 if (usbdImpl_ == nullptr) {
344 USB_HILOGE(MODULE_USB_SERVICE, "UsbAccessoryManager::usbdImpl_ is nullptr");
345 return;
346 }
347 #endif // USB_MANAGER_V2_0
348 std::lock_guard<std::mutex> guard(mutexHandleEvent_);
349 eventStatus_ = status;
350 if (delayProcess) {
351 antiShakeDelayTimer_.Unregister(antiShakeDelayTimerId_);
352 }
353 if ((status == ACT_UPDEVICE || status == ACT_DOWNDEVICE) && delayProcess) {
354 auto task = [&]() {
355 this->HandleEvent(this->eventStatus_, false);
356 return;
357 };
358 antiShakeDelayTimerId_ = antiShakeDelayTimer_.Register(task, ANTI_SHAKE_INTERVAL, true);
359 return;
360 }
361 int32_t curAccStatus = ACC_NONE;
362 switch (status) {
363 case ACT_UPDEVICE: {
364 if (accStatus_ == ACC_CONFIGURING) {
365 curAccStatus = ACC_START;
366 }
367 break;
368 }
369 case ACT_ACCESSORYUP: {
370 curAccStatus = ACC_CONFIGURING;
371 break;
372 }
373 case ACT_DOWNDEVICE:
374 case ACT_ACCESSORYDOWN: {
375 curAccStatus = ACC_STOP;
376 break;
377 }
378 case ACT_ACCESSORYSEND: {
379 curAccStatus = ACC_SEND;
380 break;
381 }
382 default:
383 USB_HILOGE(MODULE_USB_SERVICE, "invalid status %{public}d", status);
384 }
385 ProcessHandle(curAccStatus);
386 }
387
ProcessHandle(int32_t curAccStatus)388 void UsbAccessoryManager::ProcessHandle(int32_t curAccStatus)
389 {
390 int32_t ret = UEC_INTERFACE_INVALID_VALUE;
391 if ((curAccStatus == ACC_CONFIGURING || curAccStatus == ACC_START)) {
392 accDelayTimer_.Unregister(accDelayTimerId_);
393
394 int32_t curFunc = 0;
395 ret = GetCurrentFunctions(curFunc);
396 if (ret != UEC_OK) {
397 USB_HILOGE(MODULE_USB_SERVICE, "GetCurrentFunctions ret: %{public}d", ret);
398 return;
399 }
400 this->curDeviceFunc_ = curFunc;
401 ret = ProcessAccessoryStart(curFunc, curAccStatus);
402 if (ret != UEC_OK) {
403 USB_HILOGE(MODULE_USB_SERVICE, "ProcessAccessoryStart ret: %{public}d", ret);
404 return;
405 }
406 } else if (curAccStatus == ACC_STOP && accStatus_ != ACC_CONFIGURING) {
407 ret = ProcessAccessoryStop(curDeviceFunc_, curAccStatus);
408 if (ret != UEC_OK) {
409 USB_HILOGE(MODULE_USB_SERVICE, "ProcessAccessoryStop ret: %{public}d", ret);
410 return;
411 }
412 } else if (curAccStatus == ACC_SEND) {
413 ProcessAccessorySend();
414 }
415 return;
416 }
417
SerialValueHash(const std::string & serialValue)418 std::string UsbAccessoryManager::SerialValueHash(const std::string&serialValue)
419 {
420 uint64_t timestamp = 0;
421 auto now = std::chrono::system_clock::now();
422 auto duration = now.time_since_epoch();
423 auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
424 timestamp = static_cast<uint64_t>(millis);
425
426 std::hash<std::string> string_hash;
427 std::hash<uint64_t> int_hash;
428
429 uint32_t hashValue = (string_hash(serialValue) ^ (int_hash(timestamp) << 1));
430
431 std::stringstream ss;
432 ss << std::hex << std::setw(NUM_OF_SERAIL_BIT) << std::setfill('0') << hashValue;
433 return ss.str();
434 }
435
InitBase64Map()436 void UsbAccessoryManager::InitBase64Map()
437 {
438 for (size_t i = 0; i < BASE_64_CHARS.size(); ++i) {
439 base64Map_[BASE_64_CHARS[i]] = static_cast<int>(i);
440 }
441 }
442
IsBase64(unsigned char c)443 bool IsBase64(unsigned char c)
444 {
445 return (isalnum(c) || (c == '+') || (c == '/'));
446 }
447
Base64Decode(const std::string & basicString)448 std::vector<uint8_t> UsbAccessoryManager::Base64Decode(const std::string& basicString)
449 {
450 std::string decoded_data;
451 uint32_t i = 0;
452 int index = 0;
453 int len = static_cast<int>(basicString.size());
454 unsigned char charArray3[INDEX_FORTH];
455 unsigned char charArray4[INDEX_FIFTH];
456
457 while (len-- && (basicString[index] != '=') && IsBase64(basicString[index])) {
458 charArray4[i++] = basicString[index];
459 index++;
460 if (i == sizeof(charArray4)) {
461 for (i = 0; i < sizeof(charArray4); i++) {
462 charArray4[i] = BASE_64_CHARS.find(charArray4[i]);
463 }
464 charArray3[INDEX_FIRST] = (charArray4[INDEX_FIRST] << OFFSET2) +
465 ((charArray4[INDEX_SECOND] & 0x30) >> OFFSET4);
466 charArray3[INDEX_SECOND] = ((charArray4[INDEX_SECOND] & 0xf) << OFFSET4) +
467 ((charArray4[INDEX_THIRD] & 0x3c) >> OFFSET2);
468 charArray3[INDEX_THIRD] = ((charArray4[INDEX_THIRD] & 0x3) << OFFSET6) + charArray4[INDEX_FORTH];
469 for (i = 0; i < sizeof(charArray3); i++) {
470 decoded_data += charArray3[i];
471 }
472 i = 0;
473 }
474 }
475
476 if (i) {
477 uint32_t j = 0;
478 for (j = i; j < sizeof(charArray4); j++) {
479 charArray4[j] = 0;
480 }
481 for (j = 0; j < sizeof(charArray4); j++) {
482 charArray4[j] = BASE_64_CHARS.find(charArray4[j]);
483 }
484 charArray3[INDEX_FIRST] = (charArray4[INDEX_FIRST] << OFFSET2) +
485 ((charArray4[INDEX_SECOND] & 0x30) >> OFFSET4);
486 charArray3[INDEX_SECOND] = ((charArray4[INDEX_SECOND] & 0xf) << OFFSET4) +
487 ((charArray4[INDEX_THIRD] & 0x3c) >> OFFSET2);
488 charArray3[INDEX_THIRD] = ((charArray4[INDEX_THIRD] & 0x3) << OFFSET6) + charArray4[INDEX_FORTH];
489 for (j = 0; j < i - 1; j++) {
490 decoded_data += charArray3[j];
491 }
492 }
493
494 std::vector<uint8_t> ret;
495 for (char c : decoded_data) {
496 ret.push_back(static_cast<uint8_t>(c));
497 }
498
499 return ret;
500 }
501
compare(const std::string & s1,const std::string & s2)502 bool UsbAccessoryManager::compare(const std::string &s1, const std::string &s2)
503 {
504 if (s1.empty())
505 return (s2.empty());
506 return s1 == s2;
507 }
508
GetAccessorySerialNumber(const USBAccessory & access,const std::string & bundleName,std::string & serialValue)509 int32_t UsbAccessoryManager::GetAccessorySerialNumber(const USBAccessory &access,
510 const std::string &bundleName, std::string &serialValue)
511 {
512 USB_HILOGD(MODULE_USB_SERVICE, "%{public}s, bundleName: %{public}s, serial: %{public}s",
513 __func__, bundleName.c_str(), this->accessory.GetSerialNumber().c_str());
514 if (accStatus_ != ACC_START) {
515 USB_HILOGE(MODULE_USB_SERVICE, "invalid status %{public}d", accStatus_);
516 return UEC_SERVICE_ACCESSORY_NOT_MATCH;
517 } else if (compare(this->accessory.GetManufacturer(), access.GetManufacturer()) &&
518 (compare(this->accessory.GetProduct(), access.GetProduct())) &&
519 compare(this->accessory.GetDescription(), access.GetDescription()) &&
520 compare(this->accessory.GetManufacturer(), access.GetManufacturer()) &&
521 compare(this->accessory.GetVersion(), access.GetVersion()) &&
522 (compare(this->accessory.GetSerialNumber(), access.GetSerialNumber()) ||
523 compare(bundleName + this->accessory.GetSerialNumber(), access.GetSerialNumber()))) {
524 serialValue = access.GetManufacturer() + access.GetProduct() + access.GetVersion() + access.GetSerialNumber();
525 return UEC_OK;
526 }
527 return UEC_SERVICE_ACCESSORY_NOT_MATCH;
528 }
529 // LCOV_EXCL_STOP
530
531 } // USB
532 } // OHOS
533