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 "avrcp_ct_vendor.h"
17 #include "avrcp_ct_vendor_continuation.h"
18 #include "avrcp_ct_vendor_player_application_settings.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace bluetooth {
23 /******************************************************************
24 * AvrcCtVendorPacket *
25 ******************************************************************/
26
AvrcCtVendorPacket()27 AvrcCtVendorPacket::AvrcCtVendorPacket() : AvrcCtPacket(), status_(AVRC_ES_CODE_INVALID)
28 {
29 HILOGI("enter");
30 }
31
~AvrcCtVendorPacket()32 AvrcCtVendorPacket::~AvrcCtVendorPacket()
33 {
34 HILOGI("enter");
35
36 if (pkt_ != nullptr) {
37 PacketFree(pkt_);
38 pkt_ = nullptr;
39 }
40 }
41
AssemblePacket(void)42 const Packet *AvrcCtVendorPacket::AssemblePacket(void)
43 {
44 HILOGI("enter");
45
46 pkt_ = AssembleFixedOperands();
47 pkt_ = AssembleParameters(pkt_);
48
49 return pkt_;
50 }
51
DisassemblePacket(Packet * pkt)52 bool AvrcCtVendorPacket::DisassemblePacket(Packet *pkt)
53 {
54 HILOGI("enter");
55
56 isValid_ = IsValidParameterLength(pkt);
57 if (isValid_) {
58 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
59
60 uint16_t offset = AVRC_CT_VENDOR_CTYPE_OFFSET;
61 uint64_t payload = 0x00;
62 PopOctets1((buffer + offset), payload);
63 crCode_ = static_cast<uint8_t>(payload);
64 HILOGI("crCode_: %{public}x", crCode_);
65
66 offset = AVRC_CT_VENDOR_COMPANY_ID_OFFSET;
67 payload = 0x00;
68 PopOctets3((buffer + offset), payload);
69 companyId_ = static_cast<uint32_t>(payload);
70 HILOGI("companyId_: %{public}x", companyId_);
71
72 offset = AVRC_CT_VENDOR_PACKET_TYPE_OFFSET;
73 payload = 0x00;
74 PopOctets1((buffer + offset), payload);
75 packetType_ = static_cast<uint8_t>(payload);
76 HILOGI("packetType_: %{public}x", packetType_);
77
78 if ((crCode_ == AVRC_CT_RSP_CODE_REJECTED || crCode_ == AVRC_CT_RSP_CODE_NOT_IMPLEMENTED) &&
79 parameterLength_ == AVRC_TG_VENDOR_REJECT_PARAMETER_LENGTH) {
80 isValid_ = false;
81 offset = AVRC_CT_VENDOR_STATUS_OFFSET;
82 payload = 0x00;
83 PopOctets1((buffer + offset), payload);
84 status_ = static_cast<uint8_t>(payload);
85 HILOGI("status_: %{public}x", status_);
86 } else {
87 isValid_ = DisassembleParameters(buffer);
88 }
89 } else {
90 HILOGI("The parameter length is invalid!");
91 }
92
93 return isValid_;
94 }
95
AssembleFixedOperands(void)96 Packet *AvrcCtVendorPacket::AssembleFixedOperands(void)
97 {
98 HILOGI("enter");
99
100 pkt_ = PacketMalloc(0x00, 0x00, AVRC_CT_VENDOR_MIN_COMMAND_SIZE);
101 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt_)));
102
103 uint16_t offset = 0x00;
104 offset += PushOctets1((buffer + offset), crCode_);
105 HILOGI("crCode_: %{public}x", crCode_);
106
107 offset += PushOctets1((buffer + offset), (subunitType_ << AVRC_CT_VENDOR_MOVE_BIT_3) | subunitId_);
108 HILOGI("subunitId_: %{public}x, subunitType_: %{public}x, subunitType_ << 3 | subunitId_: %{public}x",
109 subunitId_, subunitType_, (subunitType_ << AVRC_CT_VENDOR_MOVE_BIT_3) | subunitId_);
110
111 offset += PushOctets1((buffer + offset), opCode_);
112 HILOGI("opCode_: %{public}x", opCode_);
113
114 offset += PushOctets3((buffer + offset), companyId_);
115 HILOGI("companyId_: %{public}x", companyId_);
116
117 offset += PushOctets1((buffer + offset), pduId_);
118 HILOGI("pduId_: %{public}x", pduId_);
119
120 PushOctets1((buffer + offset), packetType_);
121 HILOGI("packetType_: %{public}x", packetType_);
122
123 return pkt_;
124 }
125
IsValidParameterLength(Packet * pkt)126 bool AvrcCtVendorPacket::IsValidParameterLength(Packet *pkt)
127 {
128 HILOGI("enter");
129
130 bool result = false;
131
132 size_t size = PacketPayloadSize(pkt);
133 if (size >= AVRC_CT_VENDOR_FIXED_OPERAND_SIZE) {
134 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
135
136 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
137 uint64_t payload = 0x00;
138 PopOctets2((buffer + offset), payload);
139 parameterLength_ = static_cast<uint32_t>(payload);
140 HILOGI("parameterLength_: %{public}d", parameterLength_);
141
142 if (size - AVRC_CT_VENDOR_FIXED_OPERAND_SIZE == parameterLength_) {
143 result = true;
144 }
145 } else {
146 HILOGI("The size of the packet is invalid! actual size: %{public}zu valid min size: %{public}ju",
147 size, AVRC_CT_VENDOR_FIXED_OPERAND_SIZE);
148 }
149
150 return result;
151 }
152
153 /******************************************************************
154 * GetCapability *
155 ******************************************************************/
156
AvrcCtGcPacket(uint8_t capabilityId)157 AvrcCtGcPacket::AvrcCtGcPacket(uint8_t capabilityId) : AvrcCtVendorPacket()
158 {
159 HILOGI("enter");
160
161 crCode_ = AVRC_CT_CMD_CODE_STATUS;
162 pduId_ = AVRC_CT_PDU_ID_GET_CAPABILITIES;
163 parameterLength_ = AVRC_CT_GC_PARAMETER_LENGTH;
164 capabilityId_ = capabilityId;
165 }
166
AvrcCtGcPacket(Packet * pkt)167 AvrcCtGcPacket::AvrcCtGcPacket(Packet *pkt) : AvrcCtVendorPacket()
168 {
169 HILOGI("enter");
170
171 crCode_ = AVRC_CT_CMD_CODE_STATUS;
172 pduId_ = AVRC_CT_PDU_ID_GET_CAPABILITIES;
173
174 DisassemblePacket(pkt);
175 }
176
~AvrcCtGcPacket()177 AvrcCtGcPacket::~AvrcCtGcPacket()
178 {
179 HILOGI("enter");
180
181 companies_.clear();
182 events_.clear();
183 }
184
AssembleParameters(Packet * pkt)185 Packet *AvrcCtGcPacket::AssembleParameters(Packet *pkt)
186 {
187 HILOGI("enter");
188
189 auto buffer = BufferMalloc(AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GC_PARAMETER_LENGTH);
190 if (buffer == nullptr) {
191 HILOGE("BufferMalloc fail");
192 return pkt;
193 }
194 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
195 HILOGI("BufferMalloc: %{public}ju", (AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GC_PARAMETER_LENGTH));
196
197 uint16_t offset = 0x0000;
198 offset += PushOctets2((bufferPtr + offset), parameterLength_);
199 HILOGI("parameterLength_: %{public}hu", parameterLength_);
200
201 PushOctets1((bufferPtr + offset), capabilityId_);
202 HILOGI("capabilityId_: %{public}hhu", capabilityId_);
203
204 PacketPayloadAddLast(pkt, buffer);
205
206 BufferFree(buffer);
207 buffer = nullptr;
208 bufferPtr = nullptr;
209
210 return pkt;
211 }
212
DisassembleParameters(uint8_t * buffer)213 bool AvrcCtGcPacket::DisassembleParameters(uint8_t *buffer)
214 {
215 HILOGI("enter");
216
217 isValid_ = false;
218
219 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
220 uint64_t payload = 0x00;
221 offset += PopOctets2((buffer + offset), payload);
222 parameterLength_ = static_cast<uint16_t>(payload);
223 HILOGI("parameterLength_: %{public}d", parameterLength_);
224
225 offset += PopOctets1((buffer + offset), payload);
226 capabilityId_ = static_cast<uint8_t>(payload);
227 HILOGI("capabilityId_: %{public}d", capabilityId_);
228
229 offset += PopOctets1((buffer + offset), payload);
230 capabilityCount_ = static_cast<uint8_t>(payload);
231 HILOGI("capabilityCount_: %{public}d", capabilityCount_);
232
233 if (capabilityId_ == AVRC_CAPABILITY_COMPANYID) {
234 for (int i = 0; i < capabilityCount_; i++) {
235 payload = 0x00;
236 offset += PopOctets3((buffer + offset), payload);
237 companies_.push_back(payload);
238 HILOGI("companyId_: %{public}x", static_cast<uint32_t>(payload));
239 }
240 } else if (capabilityId_ == AVRC_CAPABILITY_EVENTID) {
241 for (int i = 0; i < capabilityCount_; i++) {
242 payload = 0x00;
243 offset += PopOctets1((buffer + offset), payload);
244 events_.push_back(static_cast<uint8_t>(payload));
245 HILOGI("events_: %{public}x", static_cast<uint8_t>(payload));
246 }
247 }
248
249 isValid_ = true;
250
251 return isValid_;
252 }
253
254 /******************************************************************
255 * ListPlayerApplicationSettingAttribute *
256 ******************************************************************/
257
AvrcCtLpasaPacket()258 AvrcCtLpasaPacket::AvrcCtLpasaPacket() : AvrcCtVendorPacket()
259 {
260 HILOGI("enter");
261
262 crCode_ = AVRC_CT_CMD_CODE_STATUS;
263 pduId_ = AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES;
264 parameterLength_ = AVRC_CT_LPASA_PARAMETER_LENGTH;
265 }
266
AvrcCtLpasaPacket(Packet * pkt)267 AvrcCtLpasaPacket::AvrcCtLpasaPacket(Packet *pkt) : AvrcCtVendorPacket()
268 {
269 HILOGI("enter");
270
271 crCode_ = AVRC_CT_CMD_CODE_STATUS;
272 pduId_ = AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES;
273
274 DisassemblePacket(pkt);
275 }
276
~AvrcCtLpasaPacket()277 AvrcCtLpasaPacket::~AvrcCtLpasaPacket()
278 {
279 HILOGI("enter");
280
281 attributes_.clear();
282 }
283
AssembleParameters(Packet * pkt)284 Packet *AvrcCtLpasaPacket::AssembleParameters(Packet *pkt)
285 {
286 HILOGI("enter");
287
288 auto buffer = BufferMalloc(AVRC_CT_LPASA_PARAMETER_LENGTH_SIZE);
289 if (buffer == nullptr) {
290 HILOGE("BufferMalloc fail");
291 return pkt;
292 }
293 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
294 HILOGI("BufferMalloc: %{public}d", (AVRC_CT_LPASA_PARAMETER_LENGTH_SIZE));
295
296 uint16_t offset = 0x0000;
297 PushOctets2((bufferPtr + offset), parameterLength_);
298 HILOGI("parameterLength_: %{public}d", parameterLength_);
299
300 PacketPayloadAddLast(pkt, buffer);
301
302 BufferFree(buffer);
303 buffer = nullptr;
304 bufferPtr = nullptr;
305
306 return pkt;
307 }
308
DisassembleParameters(uint8_t * buffer)309 bool AvrcCtLpasaPacket::DisassembleParameters(uint8_t *buffer)
310 {
311 HILOGI("enter");
312
313 isValid_ = false;
314
315 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
316 uint64_t payload = 0x00;
317 offset += PopOctets2((buffer + offset), payload);
318 parameterLength_ = static_cast<uint16_t>(payload);
319 HILOGI("parameterLength_: %{public}d", parameterLength_);
320
321 offset += PopOctets1((buffer + offset), payload);
322 numOfAttributes_ = static_cast<uint8_t>(payload);
323 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
324
325 for (int i = 0; i < numOfAttributes_; i++) {
326 offset += PopOctets1((buffer + offset), payload);
327 attributes_.push_back(static_cast<uint8_t>(payload));
328 HILOGI("attributes: %{public}x", static_cast<uint8_t>(payload));
329 }
330 isValid_ = true;
331
332 return isValid_;
333 }
334
335 /******************************************************************
336 * ListPlayerApplicationSettingValues *
337 ******************************************************************/
338
AvrcCtLpasvPacket(uint8_t attributes)339 AvrcCtLpasvPacket::AvrcCtLpasvPacket(uint8_t attributes)
340 : AvrcCtVendorPacket(), attribute_(AVRC_PLAYER_ATTRIBUTE_ILLEGAL)
341 {
342 HILOGI("attributes: %{public}d", attributes);
343
344 crCode_ = AVRC_CT_CMD_CODE_STATUS;
345 pduId_ = AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES;
346 parameterLength_ = AVRC_CT_LPASV_PARAMETER_LENGTH;
347
348 attribute_ = attributes;
349 }
350
AvrcCtLpasvPacket(Packet * pkt)351 AvrcCtLpasvPacket::AvrcCtLpasvPacket(Packet *pkt) : AvrcCtVendorPacket(), attribute_(AVRC_PLAYER_ATTRIBUTE_ILLEGAL)
352 {
353 HILOGI("enter");
354
355 crCode_ = AVRC_CT_CMD_CODE_STATUS;
356 pduId_ = AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES;
357
358 DisassemblePacket(pkt);
359 }
360
~AvrcCtLpasvPacket()361 AvrcCtLpasvPacket::~AvrcCtLpasvPacket()
362 {
363 HILOGI("enter");
364
365 values_.clear();
366 }
367
AssembleParameters(Packet * pkt)368 Packet *AvrcCtLpasvPacket::AssembleParameters(Packet *pkt)
369 {
370 HILOGI("enter");
371
372 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_LPASV_PARAMETER_LENGTH;
373 HILOGI("BufferMalloc: %{public}zu", bufferSize);
374
375 auto buffer = BufferMalloc(bufferSize);
376 if (buffer == nullptr) {
377 HILOGE("BufferMalloc fail");
378 return pkt;
379 }
380 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
381
382 uint16_t offset = 0x0000;
383 offset += PushOctets2((bufferPtr + offset), parameterLength_);
384 HILOGI("parameterLength_: %{public}d", parameterLength_);
385
386 PushOctets1((bufferPtr + offset), attribute_);
387 HILOGI("attribute_: %{public}x", attribute_);
388
389 PacketPayloadAddLast(pkt, buffer);
390
391 BufferFree(buffer);
392 buffer = nullptr;
393 bufferPtr = nullptr;
394
395 return pkt;
396 }
397
DisassembleParameters(uint8_t * buffer)398 bool AvrcCtLpasvPacket::DisassembleParameters(uint8_t *buffer)
399 {
400 HILOGI("enter");
401
402 isValid_ = false;
403
404 receivedFragments_++;
405 HILOGI("receivedFragments_: %{public}hhu", receivedFragments_);
406
407 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
408 uint64_t payload = 0x00;
409 offset += PopOctets2((buffer + offset), payload);
410 parameterLength_ = static_cast<uint16_t>(payload);
411 HILOGI("parameterLength_: %{public}d", parameterLength_);
412
413 offset += PopOctets1((buffer + offset), payload);
414 numOfValues_ = static_cast<uint8_t>(payload);
415 HILOGI("numOfValues_: %{public}d", numOfValues_);
416
417 for (int i = 0; i < numOfValues_; i++) {
418 offset += PopOctets1((buffer + offset), payload);
419 values_.push_back(static_cast<uint8_t>(payload));
420 HILOGI("value: %{public}x", values_.back());
421 }
422
423 numOfValues_ = values_.size();
424
425 HILOGI("values_.size: %{public}zu", values_.size());
426
427 if (numOfValues_ == values_.size() && numOfValues_ > 0) {
428 isValid_ = true;
429 }
430
431 HILOGI("isValid_: %{public}d", isValid_);
432
433 return isValid_;
434 }
435
IsValidAttribute(void) const436 bool AvrcCtLpasvPacket::IsValidAttribute(void) const
437 {
438 HILOGI("enter");
439
440 bool result = false;
441
442 do {
443 if (attribute_ == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
444 break;
445 }
446
447 if (attribute_ >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN && attribute_ <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
448 break;
449 }
450
451 result = true;
452 } while (false);
453
454 HILOGI("result: %{public}d", result);
455
456 return result;
457 }
458
459 /******************************************************************
460 * GetCurrentPlayerApplicationSettingValue *
461 ******************************************************************/
462
AvrcCtGcpasvPacket(const std::vector<uint8_t> & attributes)463 AvrcCtGcpasvPacket::AvrcCtGcpasvPacket(const std::vector<uint8_t> &attributes) : AvrcCtVendorPacket()
464 {
465 HILOGI("enter");
466
467 crCode_ = AVRC_CT_CMD_CODE_STATUS;
468 pduId_ = AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE;
469 attributes_ = attributes;
470 }
471
AvrcCtGcpasvPacket(Packet * pkt)472 AvrcCtGcpasvPacket::AvrcCtGcpasvPacket(Packet *pkt) : AvrcCtVendorPacket()
473 {
474 HILOGI("enter");
475
476 crCode_ = AVRC_CT_CMD_CODE_STATUS;
477 pduId_ = AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE;
478
479 DisassemblePacket(pkt);
480 }
481
~AvrcCtGcpasvPacket()482 AvrcCtGcpasvPacket::~AvrcCtGcpasvPacket()
483 {
484 HILOGI("enter");
485
486 attributes_.clear();
487 values_.clear();
488 }
489
AssembleParameters(Packet * pkt)490 Packet *AvrcCtGcpasvPacket::AssembleParameters(Packet *pkt)
491 {
492 HILOGI("enter");
493
494 size_t bufferSize =
495 AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GCPASV_NUM_OF_ATTRIBUTES_SIZE + attributes_.size();
496 HILOGI("BufferMalloc: %{public}zu", bufferSize);
497
498 auto buffer = BufferMalloc(bufferSize);
499 if (buffer == nullptr) {
500 HILOGE("BufferMalloc fail");
501 return pkt;
502 }
503 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
504
505 uint16_t offset = 0x0000;
506 parameterLength_ = bufferSize - AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE;
507 offset += PushOctets2((bufferPtr + offset), parameterLength_);
508 HILOGI("parameterLength_: %{public}d", parameterLength_);
509
510 numOfAttributes_ = attributes_.size();
511 offset += PushOctets1((bufferPtr + offset), numOfAttributes_);
512 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
513
514 for (auto attribute : attributes_) {
515 offset += PushOctets1((bufferPtr + offset), attribute);
516 HILOGI("attribute: %{public}x", attribute);
517 }
518
519 PacketPayloadAddLast(pkt, buffer);
520
521 BufferFree(buffer);
522 buffer = nullptr;
523 bufferPtr = nullptr;
524
525 return pkt;
526 }
527
DisassembleParameters(uint8_t * buffer)528 bool AvrcCtGcpasvPacket::DisassembleParameters(uint8_t *buffer)
529 {
530 HILOGI("enter");
531
532 isValid_ = false;
533
534 receivedFragments_++;
535 HILOGI("receivedFragments_: %{public}d", receivedFragments_);
536
537 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
538 uint64_t payload = 0x00;
539 offset += PopOctets2((buffer + offset), payload);
540 parameterLength_ = static_cast<uint16_t>(payload);
541 HILOGI("parameterLength_: %{public}d", parameterLength_);
542
543 offset += PopOctets1((buffer + offset), payload);
544 numOfValues_ = static_cast<uint8_t>(payload);
545 HILOGI("numOfValues_: %{public}d", numOfValues_);
546
547 for (int i = 0; i < numOfValues_; i++) {
548 offset += PopOctets1((buffer + offset), payload);
549 attributes_.push_back(static_cast<uint8_t>(payload));
550 HILOGI("attribute: %{public}x", attributes_.back());
551
552 offset += PopOctets1((buffer + offset), payload);
553 values_.push_back(static_cast<uint8_t>(payload));
554 HILOGI("value: %{public}x", values_.back());
555 }
556
557 if (numOfValues_ == values_.size() && numOfValues_ > 0) {
558 isValid_ = true;
559 }
560
561 HILOGI("isValid_: %{public}d", isValid_);
562
563 return isValid_;
564 }
565
IsValidAttribute(void) const566 bool AvrcCtGcpasvPacket::IsValidAttribute(void) const
567 {
568 HILOGI("enter");
569
570 bool result = false;
571
572 for (auto attribute : attributes_) {
573 do {
574 if (attribute == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
575 break;
576 }
577
578 if (attribute >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN && attribute <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
579 break;
580 }
581
582 result = true;
583 } while (false);
584 }
585
586 HILOGI("result: %{public}d", result);
587
588 return result;
589 }
590
591 /******************************************************************
592 * SetPlayerApplicationSettingValue *
593 ******************************************************************/
594
AvrcCtSpasvPacket(const std::vector<uint8_t> & attributes,const std::vector<uint8_t> & values)595 AvrcCtSpasvPacket::AvrcCtSpasvPacket(const std::vector<uint8_t> &attributes, const std::vector<uint8_t> &values)
596 : AvrcCtVendorPacket()
597 {
598 HILOGI("enter");
599
600 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
601 pduId_ = AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE;
602
603 attributes_ = attributes;
604 values_ = values;
605 }
606
AvrcCtSpasvPacket(Packet * pkt)607 AvrcCtSpasvPacket::AvrcCtSpasvPacket(Packet *pkt) : AvrcCtVendorPacket()
608 {
609 HILOGI("enter");
610
611 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
612 pduId_ = AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE;
613
614 DisassemblePacket(pkt);
615 }
616
~AvrcCtSpasvPacket()617 AvrcCtSpasvPacket::~AvrcCtSpasvPacket()
618 {
619 HILOGI("enter");
620
621 attributes_.clear();
622 values_.clear();
623 }
624
AssembleParameters(Packet * pkt)625 Packet *AvrcCtSpasvPacket::AssembleParameters(Packet *pkt)
626 {
627 HILOGI("enter");
628
629 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_SPASV_NUM_OF_ATTRIBUTES_SIZE +
630 attributes_.size() + values_.size();
631 HILOGI("BufferMalloc: %{public}zu", bufferSize);
632
633 auto buffer = BufferMalloc(bufferSize);
634 if (buffer == nullptr) {
635 HILOGE("BufferMalloc fail");
636 return pkt;
637 }
638 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
639
640 uint16_t offset = 0x0000;
641 parameterLength_ = AVRC_CT_SPASV_NUM_OF_ATTRIBUTES_SIZE + attributes_.size() + values_.size();
642 offset += PushOctets2((bufferPtr + offset), parameterLength_);
643 HILOGI("parameterLength_: %{public}d", parameterLength_);
644
645 numOfAttributes_ = attributes_.size();
646 offset += PushOctets1((bufferPtr + offset), numOfAttributes_);
647 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
648
649 for (int i = 0; i < numOfAttributes_; i++) {
650 offset += PushOctets1((bufferPtr + offset), attributes_.at(i));
651 HILOGI("attribute: %{public}x", attributes_.at(i));
652 offset += PushOctets1((bufferPtr + offset), values_.at(i));
653 HILOGI("value: %{public}x", values_.at(i));
654 }
655
656 PacketPayloadAddLast(pkt, buffer);
657
658 BufferFree(buffer);
659 buffer = nullptr;
660 bufferPtr = nullptr;
661
662 return pkt;
663 }
664
DisassembleParameters(uint8_t * buffer)665 bool AvrcCtSpasvPacket::DisassembleParameters(uint8_t *buffer)
666 {
667 HILOGI("enter");
668
669 isValid_ = false;
670
671 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
672 uint64_t payload = 0x00;
673 PopOctets2((buffer + offset), payload);
674 parameterLength_ = static_cast<uint16_t>(payload);
675 HILOGI("parameterLength_: %{public}d", parameterLength_);
676
677 isValid_ = true;
678
679 HILOGI("isValid_: %{public}d", isValid_);
680
681 return isValid_;
682 }
683
IsValidAttribute(void) const684 bool AvrcCtSpasvPacket::IsValidAttribute(void) const
685 {
686 HILOGI("enter");
687
688 bool result = false;
689
690 for (auto attribute : attributes_) {
691 do {
692 if (attribute == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
693 break;
694 }
695
696 if (attribute >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN && attribute <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
697 break;
698 }
699
700 result = true;
701 } while (false);
702 }
703
704 HILOGI("result: %{public}d", result);
705
706 return result;
707 }
708
709 /******************************************************************
710 * GetPlayerApplicationSettingAttributeText *
711 ******************************************************************/
712
AvrcCtGpasatPacket(std::vector<uint8_t> attributes)713 AvrcCtGpasatPacket::AvrcCtGpasatPacket(std::vector<uint8_t> attributes) : AvrcCtVendorPacket()
714 {
715 HILOGI("enter");
716
717 crCode_ = AVRC_CT_CMD_CODE_STATUS;
718 pduId_ = AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT;
719 attributes_ = attributes;
720 numOfAttributes_ = attributes.size();
721 }
722
AvrcCtGpasatPacket(Packet * pkt)723 AvrcCtGpasatPacket::AvrcCtGpasatPacket(Packet *pkt) : AvrcCtVendorPacket()
724 {
725 HILOGI("enter");
726
727 crCode_ = AVRC_CT_CMD_CODE_STATUS;
728 pduId_ = AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT;
729
730 DisassemblePacket(pkt);
731 }
732
~AvrcCtGpasatPacket()733 AvrcCtGpasatPacket::~AvrcCtGpasatPacket()
734 {
735 HILOGI("enter");
736
737 attributes_.clear();
738 attributeName_.clear();
739 }
740
AssembleParameters(Packet * pkt)741 Packet *AvrcCtGpasatPacket::AssembleParameters(Packet *pkt)
742 {
743 HILOGI("enter");
744
745 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GPASAT_ATTRIBUTE_NUM_LENGTH + attributes_.size();
746 HILOGI("BufferMalloc: %{public}zu", bufferSize);
747 auto buffer = BufferMalloc(bufferSize);
748 if (buffer == nullptr) {
749 HILOGE("BufferMalloc fail");
750 return pkt;
751 }
752 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
753
754 uint16_t offset = 0x0000;
755 parameterLength_ = bufferSize - AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE;
756 offset += PushOctets2((bufferPtr + offset), parameterLength_);
757 HILOGI("parameterLength_: %{public}d", parameterLength_);
758
759 offset += PushOctets1((bufferPtr + offset), numOfAttributes_);
760 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
761
762 for (auto attribute : attributes_) {
763 offset += PushOctets1((bufferPtr + offset), attribute);
764 HILOGI("attribute: %{public}x", attribute);
765 }
766
767 PacketPayloadAddLast(pkt, buffer);
768
769 BufferFree(buffer);
770 buffer = nullptr;
771 bufferPtr = nullptr;
772
773 return pkt;
774 }
775
DisassembleParameters(uint8_t * buffer)776 bool AvrcCtGpasatPacket::DisassembleParameters(uint8_t *buffer)
777 {
778 HILOGI("enter");
779
780 isValid_ = false;
781
782 receivedFragments_++;
783 HILOGI("receivedFragments_: %{public}d", receivedFragments_);
784
785 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
786 uint64_t payload = 0x00;
787 offset += PopOctets2((buffer + offset), payload);
788 parameterLength_ = static_cast<uint16_t>(payload);
789 HILOGI("parameterLength_: %{public}d", parameterLength_);
790
791 offset += PopOctets1((buffer + offset), payload);
792 numOfAttributes_ = static_cast<uint8_t>(payload);
793 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
794
795 for (int i = 0; i < numOfAttributes_; i++) {
796 offset += PopOctets1((buffer + offset), payload);
797 attributes_.push_back(static_cast<uint32_t>(payload));
798 HILOGI("attributeId: %{public}x", attributes_.back());
799
800 offset += PopOctets2((buffer + offset), payload);
801 HILOGI("characterSetID: %{public}x", static_cast<uint16_t>(payload));
802
803 offset += PopOctets1((buffer + offset), payload);
804 AttributeValueLength_ = static_cast<uint8_t>(payload);
805 HILOGI("AttributeValueLength: %{public}d", AttributeValueLength_);
806
807 char *tempName = nullptr;
808 tempName = new char[AttributeValueLength_ + 1];
809 for (int j = 0; j < AttributeValueLength_; j++) {
810 payload = 0x00;
811 offset += PopOctets1((buffer + offset), payload);
812 tempName[j] = static_cast<char>(payload);
813 }
814 tempName[AttributeValueLength_] = '\0';
815 std::string name(tempName);
816 AvrcpCtSafeDeleteArray(tempName, AttributeValueLength_ + 1);
817 attributeName_.push_back(name);
818 HILOGI("AttributeValue: %{public}s", attributeName_.back().c_str());
819 }
820
821 isValid_ = true;
822 HILOGI("result: %{public}d", isValid_);
823
824 return isValid_;
825 }
826
827 /******************************************************************
828 * GetPlayerApplicationSettingValueText *
829 ******************************************************************/
830
AvrcCtGpasvtPacket(uint8_t attribtueId,std::vector<uint8_t> values)831 AvrcCtGpasvtPacket::AvrcCtGpasvtPacket(uint8_t attribtueId, std::vector<uint8_t> values)
832 : AvrcCtVendorPacket(), attributeId_(AVRC_PLAYER_ATTRIBUTE_ILLEGAL)
833 {
834 HILOGI("attribtueId: %{public}d", attribtueId);
835
836 crCode_ = AVRC_CT_CMD_CODE_STATUS;
837 pduId_ = AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT;
838 values_ = values;
839 numOfValues_ = values.size();
840 attributeId_ = attribtueId;
841 }
842
AvrcCtGpasvtPacket(Packet * pkt)843 AvrcCtGpasvtPacket::AvrcCtGpasvtPacket(Packet *pkt) : AvrcCtVendorPacket(), attributeId_(AVRC_PLAYER_ATTRIBUTE_ILLEGAL)
844 {
845 HILOGI("enter");
846
847 crCode_ = AVRC_CT_CMD_CODE_STATUS;
848 pduId_ = AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT;
849
850 DisassemblePacket(pkt);
851 }
852
~AvrcCtGpasvtPacket()853 AvrcCtGpasvtPacket::~AvrcCtGpasvtPacket()
854 {
855 HILOGI("enter");
856
857 values_.clear();
858 valueName_.clear();
859 }
860
AssembleParameters(Packet * pkt)861 Packet *AvrcCtGpasvtPacket::AssembleParameters(Packet *pkt)
862 {
863 HILOGI("enter");
864
865 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GPASVT_PARAMETER_LENGTH_SIZE + numOfValues_;
866 HILOGI("BufferMalloc: %{public}zu", bufferSize);
867 auto buffer = BufferMalloc(bufferSize);
868 if (buffer == nullptr) {
869 HILOGE("BufferMalloc fail");
870 return pkt;
871 }
872 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
873
874 uint16_t offset = 0x0000;
875 parameterLength_ = bufferSize - AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE;
876 offset += PushOctets2((bufferPtr + offset), parameterLength_);
877 HILOGI("parameterLength_: %{public}d", parameterLength_);
878
879 offset += PushOctets1((bufferPtr + offset), attributeId_);
880 HILOGI("attributeId_: %{public}x", attributeId_);
881
882 offset += PushOctets1((bufferPtr + offset), numOfValues_);
883 HILOGI("numOfValues_: %{public}d", numOfValues_);
884
885 for (auto value : values_) {
886 offset += PushOctets1((bufferPtr + offset), value);
887 HILOGI("value: %{public}x", value);
888 }
889
890 PacketPayloadAddLast(pkt, buffer);
891
892 BufferFree(buffer);
893 buffer = nullptr;
894 bufferPtr = nullptr;
895
896 return pkt;
897 }
898
DisassembleParameters(uint8_t * buffer)899 bool AvrcCtGpasvtPacket::DisassembleParameters(uint8_t *buffer)
900 {
901 HILOGI("enter");
902
903 isValid_ = false;
904
905 receivedFragments_++;
906 HILOGI("receivedFragments_: %{public}d", receivedFragments_);
907
908 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
909 uint64_t payload = 0x00;
910 offset += PopOctets2((buffer + offset), payload);
911 parameterLength_ = static_cast<uint16_t>(payload);
912 HILOGI("parameterLength_: %{public}d", parameterLength_);
913
914 offset += PopOctets1((buffer + offset), payload);
915 numOfValues_ = static_cast<uint8_t>(payload);
916 HILOGI("numOfValues_: %{public}d", numOfValues_);
917
918 for (int i = 0; i < numOfValues_; i++) {
919 offset += PopOctets1((buffer + offset), payload);
920 values_.push_back(static_cast<uint32_t>(payload));
921 HILOGI("valueId: %{public}d", values_.back());
922
923 offset += PopOctets2((buffer + offset), payload);
924 HILOGI("characterSetID: %{public}x", static_cast<uint16_t>(payload));
925
926 offset += PopOctets1((buffer + offset), payload);
927 AttributeValueLength_ = static_cast<uint8_t>(payload);
928 HILOGI("AttributeValueLength: %{public}d", AttributeValueLength_);
929
930 char *tempName = nullptr;
931 tempName = new char[AttributeValueLength_ + 1];
932 for (int j = 0; j < AttributeValueLength_; j++) {
933 offset += PopOctets1((buffer + offset), payload);
934 tempName[j] = static_cast<char>(payload);
935 }
936 tempName[AttributeValueLength_] = '\0';
937 std::string name(tempName);
938 AvrcpCtSafeDeleteArray(tempName, AttributeValueLength_ + 1);
939 valueName_.push_back(name);
940 HILOGI("Value: %{public}s", valueName_.back().c_str());
941 }
942
943 isValid_ = true;
944
945 HILOGI("result: %{public}d", isValid_);
946
947 return isValid_;
948 }
949
950 /******************************************************************
951 * GetElementAttribute *
952 ******************************************************************/
953
AvrcCtGeaPacket(uint64_t identifier,std::vector<uint32_t> attributes)954 AvrcCtGeaPacket::AvrcCtGeaPacket(uint64_t identifier, std::vector<uint32_t> attributes) : AvrcCtVendorPacket()
955 {
956 HILOGI("identifier: %{public}llu", static_cast<unsigned long long>(identifier));
957
958 crCode_ = AVRC_CT_CMD_CODE_STATUS;
959 pduId_ = AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES;
960 number_ = attributes.size();
961 identifier_ = identifier;
962 attributes_ = attributes;
963 }
964
AvrcCtGeaPacket(Packet * pkt)965 AvrcCtGeaPacket::AvrcCtGeaPacket(Packet *pkt) : AvrcCtVendorPacket()
966 {
967 HILOGI("enter");
968
969 crCode_ = AVRC_CT_CMD_CODE_STATUS;
970 pduId_ = AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES;
971
972 DisassemblePacket(pkt);
973 }
974
~AvrcCtGeaPacket()975 AvrcCtGeaPacket::~AvrcCtGeaPacket()
976 {
977 HILOGI("enter");
978
979 attributes_.clear();
980 values_.clear();
981 }
982
DisassemblePacketAttributes(uint8_t * buffer,uint16_t offset)983 bool AvrcCtGeaPacket::DisassemblePacketAttributes(uint8_t *buffer, uint16_t offset)
984 {
985 HILOGI("offset: %{public}d", offset);
986 uint64_t payload = 0x00;
987
988 for (int i = 0; i < number_; i++) {
989 offset += PopOctets4((buffer + offset), payload);
990 size_t pos;
991 size_t attrNum = attributes_.size();
992 for (pos = 0; pos < attrNum; pos++) {
993 if (attributes_.at(pos) == payload) {
994 break;
995 }
996 }
997 if (pos == attrNum) {
998 attributes_.push_back(static_cast<uint32_t>(payload));
999 HILOGI("attributeId: %{public}d", attributes_.back());
1000 } else {
1001 HILOGI("attributeId: %{public}d", attributes_[pos]);
1002 }
1003 offset += PopOctets2((buffer + offset), payload);
1004 auto characterSetID = static_cast<uint16_t>(payload);
1005 offset += PopOctets2((buffer + offset), payload);
1006 AttributeValueLength_ = static_cast<uint16_t>(payload);
1007 HILOGI("characterSetID:%{public}hu, AttributeValueLength_:%{public}hu", characterSetID, AttributeValueLength_);
1008 char tempName[AttributeValueLength_ + 1];
1009 if (memset_s(tempName, AttributeValueLength_ + 1, 0, AttributeValueLength_ + 1) != EOK) {
1010 return false;
1011 };
1012 int j;
1013 for (j = 0; j < AttributeValueLength_; j++) {
1014 payload = 0x00;
1015 offset += PopOctets1((buffer + offset), payload);
1016 HILOGI("offset: %{public}d", offset);
1017 tempName[j] = static_cast<char>(payload);
1018 if (offset >= parameterLength_ + AVRC_CT_VENDOR_MIN_COMMAND_SIZE + AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE ||
1019 offset >= AVRC_CT_GEA_MTU) {
1020 j++;
1021 break;
1022 }
1023 }
1024 tempName[j] = '\0';
1025 std::string name(tempName);
1026 if (pos == attrNum) {
1027 values_.push_back(name);
1028 HILOGI("AttributeValue: %{public}s", values_.back().c_str());
1029 } else {
1030 values_.at(pos).append(name);
1031 HILOGI("AttributeValue: %{public}s", values_.at(pos).c_str());
1032 }
1033 }
1034 return true;
1035 }
1036
AssembleParameters(Packet * pkt)1037 Packet *AvrcCtGeaPacket::AssembleParameters(Packet *pkt)
1038 {
1039 HILOGI("enter");
1040
1041 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GEA_IDENTIFIER_SIZE +
1042 AVRC_CT_GEA_ATTRIBUTE_COUNT_SIZE + number_ * AVRC_CT_GEA_ATTRIBUTE_SIZE;
1043 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1044 auto buffer = BufferMalloc(bufferSize);
1045 if (buffer == nullptr) {
1046 HILOGE("BufferMalloc fail");
1047 return pkt;
1048 }
1049 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1050
1051 uint16_t offset = 0x0000;
1052 parameterLength_ = bufferSize - AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE;
1053
1054 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1055 HILOGI("parameterLength_: %{public}hu", parameterLength_);
1056
1057 offset += PushOctets8((bufferPtr + offset), identifier_);
1058 HILOGI("identifier_: %{public}jx", identifier_);
1059
1060 offset += PushOctets1((bufferPtr + offset), number_);
1061 HILOGI("number_: %{public}hhu", number_);
1062
1063 for (auto attribute : attributes_) {
1064 offset += PushOctets4((bufferPtr + offset), attribute);
1065 HILOGI("attribute: %{public}x", attribute);
1066 }
1067
1068 PacketPayloadAddLast(pkt, buffer);
1069
1070 BufferFree(buffer);
1071 buffer = nullptr;
1072 bufferPtr = nullptr;
1073
1074 return pkt;
1075 }
1076
DisassembleParameters(uint8_t * buffer)1077 bool AvrcCtGeaPacket::DisassembleParameters(uint8_t *buffer)
1078 {
1079 HILOGI("enter");
1080
1081 isValid_ = false;
1082 receivedFragments_++;
1083 HILOGI("receivedFragments_: %{public}d", receivedFragments_);
1084 do {
1085 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1086 uint64_t payload = 0x00;
1087 offset += PopOctets2((buffer + offset), payload);
1088 parameterLength_ = static_cast<uint16_t>(payload);
1089 HILOGI("parameterLength_: %{public}d", parameterLength_);
1090
1091 offset += PopOctets1((buffer + offset), payload);
1092 number_ = static_cast<uint8_t>(payload);
1093 HILOGI("number_: %{public}d", number_);
1094
1095 DisassemblePacketAttributes(buffer, offset);
1096
1097 numOfAttributes_ = attributes_.size();
1098 numOfValues_ = values_.size();
1099
1100 HILOGI("values_.size: %{public}zu", values_.size());
1101
1102 if (numOfValues_ > 0) {
1103 isValid_ = true;
1104 }
1105 } while (0);
1106
1107 HILOGI("result: %{public}d", isValid_);
1108
1109 return isValid_;
1110 }
1111
1112 /******************************************************************
1113 * GetPlayStatus *
1114 ******************************************************************/
1115
AvrcCtGpsPacket()1116 AvrcCtGpsPacket::AvrcCtGpsPacket()
1117 : AvrcCtVendorPacket(),
1118 songLength_(AVRC_PLAY_STATUS_INVALID_SONG_LENGTH),
1119 songPosition_(AVRC_PLAY_STATUS_INVALID_SONG_POSITION),
1120 playStatus_(AVRC_PLAY_STATUS_ERROR)
1121 {
1122 HILOGI("enter");
1123
1124 crCode_ = AVRC_CT_CMD_CODE_STATUS;
1125 pduId_ = AVRC_CT_PDU_ID_GET_PLAY_STATUS;
1126 parameterLength_ = AVRC_CT_GPS_PARAMETER_LENGTH;
1127 }
1128
AvrcCtGpsPacket(Packet * pkt)1129 AvrcCtGpsPacket::AvrcCtGpsPacket(Packet *pkt)
1130 : AvrcCtVendorPacket(),
1131 songLength_(AVRC_PLAY_STATUS_INVALID_SONG_LENGTH),
1132 songPosition_(AVRC_PLAY_STATUS_INVALID_SONG_POSITION),
1133 playStatus_(AVRC_PLAY_STATUS_ERROR)
1134 {
1135 HILOGI("enter");
1136
1137 crCode_ = AVRC_CT_CMD_CODE_STATUS;
1138 pduId_ = AVRC_CT_PDU_ID_GET_PLAY_STATUS;
1139
1140 DisassemblePacket(pkt);
1141 }
1142
~AvrcCtGpsPacket(void)1143 AvrcCtGpsPacket::~AvrcCtGpsPacket(void)
1144 {
1145 HILOGI("enter");
1146 }
1147
AssembleParameters(Packet * pkt)1148 Packet *AvrcCtGpsPacket::AssembleParameters(Packet *pkt)
1149 {
1150 HILOGI("enter");
1151
1152 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_GPS_PARAMETER_LENGTH;
1153 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1154
1155 auto buffer = BufferMalloc(bufferSize);
1156 if (buffer == nullptr) {
1157 HILOGE("BufferMalloc fail");
1158 return pkt;
1159 }
1160 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1161
1162 uint16_t offset = 0x0000;
1163 PushOctets2((bufferPtr + offset), parameterLength_);
1164 HILOGI("parameterLength_: %{public}d", parameterLength_);
1165
1166 PacketPayloadAddLast(pkt, buffer);
1167
1168 BufferFree(buffer);
1169 buffer = nullptr;
1170 bufferPtr = nullptr;
1171
1172 return pkt;
1173 }
1174
DisassembleParameters(uint8_t * buffer)1175 bool AvrcCtGpsPacket::DisassembleParameters(uint8_t *buffer)
1176 {
1177 HILOGI("enter");
1178
1179 isValid_ = false;
1180
1181 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1182 uint64_t payload = 0x00;
1183 PopOctets2((buffer + offset), payload);
1184 parameterLength_ = static_cast<uint16_t>(payload);
1185 HILOGI("parameterLength_: %{public}d", parameterLength_);
1186
1187 switch (parameterLength_) {
1188 case AVRC_CT_VENDOR_PARAMETER_LENGTH:
1189 songLength_ = AVRC_PLAY_STATUS_INVALID_SONG_LENGTH;
1190 HILOGI("songLength_: %{public}d", songLength_);
1191
1192 songPosition_ = AVRC_PLAY_STATUS_INVALID_SONG_POSITION;
1193 HILOGI("songPosition_: %{public}d", songPosition_);
1194
1195 playStatus_ = AVRC_PLAY_STATUS_ERROR;
1196 HILOGI("playStatus_: %{public}x", playStatus_);
1197 break;
1198 default:
1199 offset = AVRC_CT_GPS_SONG_LENGTH_OFFSET;
1200 payload = 0x00;
1201 offset += PopOctets4((buffer + offset), payload);
1202 songLength_ = static_cast<uint32_t>(payload);
1203 HILOGI("songLength_: %{public}d", songLength_);
1204
1205 payload = 0x00;
1206 offset += PopOctets4((buffer + offset), payload);
1207 songPosition_ = static_cast<uint32_t>(payload);
1208 HILOGI("songPosition_: %{public}d", songPosition_);
1209
1210 payload = 0x00;
1211 PopOctets1((buffer + offset), payload);
1212 playStatus_ = static_cast<uint8_t>(payload);
1213 HILOGI("playStatus_: %{public}x", playStatus_);
1214
1215 if (crCode_ == AVRC_CT_RSP_CODE_STABLE || crCode_ == AVRC_CT_RSP_CODE_INTERIM) {
1216 isValid_ = true;
1217 }
1218 break;
1219 }
1220
1221 return isValid_;
1222 }
1223
1224 /******************************************************************
1225 * RequestContinuingResponse *
1226 ******************************************************************/
1227
AvrcCtRcrPacket()1228 AvrcCtRcrPacket::AvrcCtRcrPacket() : AvrcCtVendorPacket()
1229 {
1230 HILOGI("enter");
1231
1232 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1233 pduId_ = AVRC_CT_PDU_ID_REQUEST_CONTINUING_RESPONSE;
1234 parameterLength_ = AVRC_CT_RCR_PARAMETER_LENGTH;
1235 }
1236
AvrcCtRcrPacket(uint8_t pduId)1237 AvrcCtRcrPacket::AvrcCtRcrPacket(uint8_t pduId) : AvrcCtVendorPacket()
1238 {
1239 HILOGI("enter");
1240
1241 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1242 pduId_ = AVRC_CT_PDU_ID_REQUEST_CONTINUING_RESPONSE;
1243 parameterLength_ = AVRC_CT_RCR_PARAMETER_LENGTH;
1244 continuePduId_ = pduId;
1245 }
1246
~AvrcCtRcrPacket()1247 AvrcCtRcrPacket::~AvrcCtRcrPacket()
1248 {
1249 HILOGI("enter");
1250 }
1251
AssembleParameters(Packet * pkt)1252 Packet *AvrcCtRcrPacket::AssembleParameters(Packet *pkt)
1253 {
1254 HILOGI("enter");
1255
1256 auto buffer = BufferMalloc(AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_RCR_PARAMETER_LENGTH);
1257 if (buffer == nullptr) {
1258 HILOGE("BufferMalloc fail");
1259 return pkt;
1260 }
1261 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1262
1263 uint16_t offset = 0x0000;
1264 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1265 HILOGI("parameterLength_: %{public}d", parameterLength_);
1266
1267 PushOctets1((bufferPtr + offset), continuePduId_);
1268 HILOGI("continuePduId_: %{public}x", continuePduId_);
1269
1270 PacketPayloadAddLast(pkt, buffer);
1271
1272 BufferFree(buffer);
1273 buffer = nullptr;
1274 bufferPtr = nullptr;
1275
1276 return pkt;
1277 }
1278
DisassembleParameters(uint8_t * buffer)1279 bool AvrcCtRcrPacket::DisassembleParameters(uint8_t *buffer)
1280 {
1281 HILOGI("enter");
1282
1283 isValid_ = false;
1284
1285 return isValid_;
1286 }
1287
1288 /******************************************************************
1289 * AbortContinuingResponse *
1290 ******************************************************************/
1291
AvrcCtAcrPacket()1292 AvrcCtAcrPacket::AvrcCtAcrPacket() : AvrcCtVendorPacket()
1293 {
1294 HILOGI("enter");
1295
1296 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1297 pduId_ = AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE;
1298 parameterLength_ = AVRC_CT_ACR_PARAMETER_LENGTH;
1299 }
1300
AvrcCtAcrPacket(uint8_t pduId)1301 AvrcCtAcrPacket::AvrcCtAcrPacket(uint8_t pduId) : AvrcCtVendorPacket()
1302 {
1303 HILOGI("enter");
1304
1305 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1306 pduId_ = AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE;
1307 parameterLength_ = AVRC_CT_ACR_PARAMETER_LENGTH;
1308 continuePduId_ = pduId;
1309 }
1310
AvrcCtAcrPacket(Packet * pkt)1311 AvrcCtAcrPacket::AvrcCtAcrPacket(Packet *pkt) : AvrcCtVendorPacket()
1312 {
1313 HILOGI("enter");
1314
1315 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1316 pduId_ = AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE;
1317
1318 DisassemblePacket(pkt);
1319 }
1320
~AvrcCtAcrPacket()1321 AvrcCtAcrPacket::~AvrcCtAcrPacket()
1322 {
1323 HILOGI("enter");
1324 }
1325
AssembleParameters(Packet * pkt)1326 Packet *AvrcCtAcrPacket::AssembleParameters(Packet *pkt)
1327 {
1328 HILOGI("enter");
1329
1330 auto buffer = BufferMalloc(AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_ACR_PARAMETER_LENGTH);
1331 if (buffer == nullptr) {
1332 HILOGE("BufferMalloc fail");
1333 return pkt;
1334 }
1335 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1336
1337 uint16_t offset = 0x0000;
1338 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1339 HILOGI("parameterLength_: %{public}d", parameterLength_);
1340
1341 PushOctets1((bufferPtr + offset), continuePduId_);
1342 HILOGI("continuePduId_: %{public}x", continuePduId_);
1343
1344 PacketPayloadAddLast(pkt, buffer);
1345
1346 BufferFree(buffer);
1347 buffer = nullptr;
1348 bufferPtr = nullptr;
1349
1350 return pkt;
1351 }
1352
DisassembleParameters(uint8_t * buffer)1353 bool AvrcCtAcrPacket::DisassembleParameters(uint8_t *buffer)
1354 {
1355 HILOGI("enter");
1356
1357 isValid_ = false;
1358
1359 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1360 uint64_t payload = 0x00;
1361 PopOctets2((buffer + offset), payload);
1362 parameterLength_ = static_cast<uint16_t>(payload);
1363 HILOGI("parameterLength_: %{public}d", parameterLength_);
1364
1365 isValid_ = true;
1366
1367 return isValid_;
1368 }
1369
1370 /******************************************************************
1371 * SetAddressedPlayer *
1372 ******************************************************************/
1373
AvrcCtSapPacket(uint16_t playerId)1374 AvrcCtSapPacket::AvrcCtSapPacket(uint16_t playerId) : AvrcCtVendorPacket()
1375 {
1376 HILOGI("playerId: %{public}d", playerId);
1377
1378 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1379 pduId_ = AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER;
1380 parameterLength_ = AVRC_CT_SAP_PARAMETER_LENGTH;
1381 playerId_ = playerId;
1382 }
1383
AvrcCtSapPacket(Packet * pkt)1384 AvrcCtSapPacket::AvrcCtSapPacket(Packet *pkt) : AvrcCtVendorPacket()
1385 {
1386 HILOGI("enter");
1387
1388 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1389 pduId_ = AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER;
1390
1391 DisassemblePacket(pkt);
1392 }
1393
~AvrcCtSapPacket()1394 AvrcCtSapPacket::~AvrcCtSapPacket()
1395 {
1396 HILOGI("enter");
1397 }
1398
AssembleParameters(Packet * pkt)1399 Packet *AvrcCtSapPacket::AssembleParameters(Packet *pkt)
1400 {
1401 HILOGI("enter");
1402
1403 auto buffer = BufferMalloc(AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_SAP_PARAMETER_LENGTH);
1404 if (buffer == nullptr) {
1405 HILOGE("BufferMalloc fail");
1406 return pkt;
1407 }
1408 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1409 HILOGI("BufferMalloc: %{public}ju", (AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_SAP_PARAMETER_LENGTH));
1410
1411 uint16_t offset = 0x0000;
1412 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1413 HILOGI("parameterLength_: %{public}d", parameterLength_);
1414
1415 PushOctets2((bufferPtr + offset), playerId_);
1416 HILOGI("playerId_: %{public}d", playerId_);
1417
1418 PacketPayloadAddLast(pkt, buffer);
1419
1420 BufferFree(buffer);
1421 buffer = nullptr;
1422 bufferPtr = nullptr;
1423
1424 return pkt;
1425 }
1426
DisassembleParameters(uint8_t * buffer)1427 bool AvrcCtSapPacket::DisassembleParameters(uint8_t *buffer)
1428 {
1429 HILOGI("enter");
1430
1431 isValid_ = false;
1432
1433 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1434 uint64_t payload = 0x00;
1435 offset += PopOctets2((buffer + offset), payload);
1436 parameterLength_ = static_cast<uint16_t>(payload);
1437 HILOGI("parameterLength_: %{public}d", parameterLength_);
1438
1439 PopOctets1((buffer + offset), payload);
1440 status_ = static_cast<uint8_t>(payload);
1441 HILOGI("status_: %{public}x", status_);
1442
1443 isValid_ = true;
1444
1445 return isValid_;
1446 }
1447
1448 /******************************************************************
1449 * PlayItem *
1450 ******************************************************************/
1451
AvrcCtPiPacket(uint8_t scope,uint64_t uid,uint16_t uidCounter)1452 AvrcCtPiPacket::AvrcCtPiPacket(uint8_t scope, uint64_t uid, uint16_t uidCounter)
1453 : AvrcCtVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
1454 {
1455 HILOGI("scope: %{public}d, uid: %{public}llu, uidCounter: %{public}d",
1456 scope, static_cast<unsigned long long>(uid), uidCounter);
1457
1458 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1459 pduId_ = AVRC_CT_PDU_ID_PLAY_ITEM;
1460 parameterLength_ = AVRC_CT_PI_PARAMETER_LENGTH;
1461 scope_ = scope;
1462 uid_ = uid;
1463 uidCounter_ = uidCounter;
1464 }
1465
AvrcCtPiPacket(Packet * pkt)1466 AvrcCtPiPacket::AvrcCtPiPacket(Packet *pkt) : AvrcCtVendorPacket()
1467 {
1468 HILOGI("enter");
1469
1470 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1471 pduId_ = AVRC_CT_PDU_ID_PLAY_ITEM;
1472
1473 DisassemblePacket(pkt);
1474 }
1475
~AvrcCtPiPacket(void)1476 AvrcCtPiPacket::~AvrcCtPiPacket(void)
1477 {
1478 HILOGI("enter");
1479 }
1480
AssembleParameters(Packet * pkt)1481 Packet *AvrcCtPiPacket::AssembleParameters(Packet *pkt)
1482 {
1483 HILOGI("enter");
1484
1485 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_PI_PARAMETER_LENGTH;
1486 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1487
1488 auto buffer = BufferMalloc(bufferSize);
1489 if (buffer == nullptr) {
1490 HILOGE("BufferMalloc fail");
1491 return pkt;
1492 }
1493 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1494
1495 uint16_t offset = 0x00;
1496 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1497 HILOGI("parameterLength_: %{public}d", parameterLength_);
1498
1499 offset += PushOctets1((bufferPtr + offset), scope_);
1500 HILOGI("scope_: %{public}x", scope_);
1501
1502 offset += PushOctets8((bufferPtr + offset), uid_);
1503 HILOGI("uid_: %{public}jx", uid_);
1504
1505 PushOctets2((bufferPtr + offset), uidCounter_);
1506 HILOGI("uidCounter_: %{public}d", uidCounter_);
1507
1508 PacketPayloadAddLast(pkt, buffer);
1509
1510 BufferFree(buffer);
1511 buffer = nullptr;
1512 bufferPtr = nullptr;
1513
1514 return pkt;
1515 }
1516
DisassembleParameters(uint8_t * buffer)1517 bool AvrcCtPiPacket::DisassembleParameters(uint8_t *buffer)
1518 {
1519 HILOGI("enter");
1520
1521 isValid_ = false;
1522
1523 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1524 uint64_t payload = 0x00;
1525 offset += PopOctets2((buffer + offset), payload);
1526 parameterLength_ = static_cast<uint16_t>(payload);
1527 HILOGI("parameterLength_: %{public}d", parameterLength_);
1528
1529 PopOctets1((buffer + offset), payload);
1530 status_ = static_cast<uint8_t>(payload);
1531 HILOGI("status_: %{public}x", status_);
1532
1533 isValid_ = true;
1534
1535 return isValid_;
1536 }
1537
1538 /******************************************************************
1539 * AddToNowPlaying *
1540 ******************************************************************/
1541
AvrcCtAtnpPacket(uint8_t scope,uint64_t uid,uint16_t uidCounter)1542 AvrcCtAtnpPacket::AvrcCtAtnpPacket(uint8_t scope, uint64_t uid, uint16_t uidCounter)
1543 : AvrcCtVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
1544 {
1545 HILOGI("scope: %{public}d, uid: %{public}llu, uidCounter: %{public}d",
1546 scope, static_cast<unsigned long long>(uid), uidCounter);
1547
1548 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1549 pduId_ = AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING;
1550 parameterLength_ = AVRC_CT_ATNP_PARAMETER_LENGTH;
1551
1552 scope_ = scope;
1553 uid_ = uid;
1554 uidCounter_ = uidCounter;
1555 }
1556
AvrcCtAtnpPacket(Packet * pkt)1557 AvrcCtAtnpPacket::AvrcCtAtnpPacket(Packet *pkt) : AvrcCtVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
1558 {
1559 HILOGI("enter");
1560
1561 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1562 pduId_ = AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING;
1563
1564 DisassemblePacket(pkt);
1565 }
1566
~AvrcCtAtnpPacket()1567 AvrcCtAtnpPacket::~AvrcCtAtnpPacket()
1568 {
1569 HILOGI("enter");
1570 }
1571
AssembleParameters(Packet * pkt)1572 Packet *AvrcCtAtnpPacket::AssembleParameters(Packet *pkt)
1573 {
1574 HILOGI("enter");
1575
1576 auto buffer = BufferMalloc(AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_ATNP_PARAMETER_LENGTH);
1577 if (buffer == nullptr) {
1578 HILOGE("BufferMalloc fail");
1579 return pkt;
1580 }
1581 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1582
1583 uint16_t offset = 0x0000;
1584 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1585 HILOGI("parameterLength_: %{public}d", parameterLength_);
1586
1587 offset += PushOctets1((bufferPtr + offset), scope_);
1588 HILOGI("scope_: %{public}hhx", scope_);
1589
1590 offset += PushOctets8((bufferPtr + offset), uid_);
1591 HILOGI("uid_: %{public}jx", uid_);
1592
1593 PushOctets2((bufferPtr + offset), uidCounter_);
1594 HILOGI("uidCounter_: %{public}hu", uidCounter_);
1595
1596 PacketPayloadAddLast(pkt, buffer);
1597
1598 BufferFree(buffer);
1599 buffer = nullptr;
1600 bufferPtr = nullptr;
1601
1602 return pkt;
1603 }
1604
DisassembleParameters(uint8_t * buffer)1605 bool AvrcCtAtnpPacket::DisassembleParameters(uint8_t *buffer)
1606 {
1607 HILOGI("enter");
1608
1609 isValid_ = false;
1610
1611 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1612 uint64_t payload = 0x00;
1613 offset += PopOctets2((buffer + offset), payload);
1614 parameterLength_ = static_cast<uint16_t>(payload);
1615 HILOGI("parameterLength_: %{public}d", parameterLength_);
1616
1617 PopOctets1((buffer + offset), payload);
1618 status_ = static_cast<uint8_t>(payload);
1619 HILOGI("status_: %{public}x", status_);
1620
1621 isValid_ = true;
1622
1623 return isValid_;
1624 }
1625
1626 /******************************************************************
1627 * SetAbsoluteVolume *
1628 ******************************************************************/
1629
AvrcCtSavPacket(uint8_t volume)1630 AvrcCtSavPacket::AvrcCtSavPacket(uint8_t volume) : AvrcCtVendorPacket(), volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
1631 {
1632 HILOGI("volume: %{public}d", volume);
1633
1634 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1635 pduId_ = AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME;
1636 parameterLength_ = AVRC_CT_SAV_PARAMETER_LENGTH;
1637 volume_ = volume;
1638 }
1639
AvrcCtSavPacket(Packet * pkt)1640 AvrcCtSavPacket::AvrcCtSavPacket(Packet *pkt) : AvrcCtVendorPacket(), volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
1641 {
1642 HILOGI("enter");
1643
1644 crCode_ = AVRC_CT_CMD_CODE_CONTROL;
1645 pduId_ = AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME;
1646
1647 DisassemblePacket(pkt);
1648 }
1649
~AvrcCtSavPacket()1650 AvrcCtSavPacket::~AvrcCtSavPacket()
1651 {
1652 HILOGI("enter");
1653 }
1654
AssembleParameters(Packet * pkt)1655 Packet *AvrcCtSavPacket::AssembleParameters(Packet *pkt)
1656 {
1657 HILOGI("enter");
1658
1659 size_t bufferSize = AVRC_CT_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_CT_SAV_PARAMETER_LENGTH;
1660 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1661
1662 auto buffer = BufferMalloc(bufferSize);
1663 if (buffer == nullptr) {
1664 HILOGE("BufferMalloc fail");
1665 return pkt;
1666 }
1667 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1668
1669 uint16_t offset = 0x0000;
1670 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1671 HILOGI("parameterLength_: %{public}d", parameterLength_);
1672
1673 PushOctets1((bufferPtr + offset), volume_ & 0b01111111);
1674 HILOGI("volume_: %{public}x", volume_);
1675
1676 PacketPayloadAddLast(pkt, buffer);
1677
1678 BufferFree(buffer);
1679 buffer = nullptr;
1680 bufferPtr = nullptr;
1681
1682 return pkt;
1683 }
1684
DisassembleParameters(uint8_t * buffer)1685 bool AvrcCtSavPacket::DisassembleParameters(uint8_t *buffer)
1686 {
1687 HILOGI("enter");
1688
1689 isValid_ = false;
1690
1691 uint16_t offset = AVRC_CT_VENDOR_PARAMETER_LENGTH_OFFSET;
1692 uint64_t payload = 0x00;
1693 offset += PopOctets2((buffer + offset), payload);
1694 parameterLength_ = static_cast<uint16_t>(payload);
1695 HILOGI("parameterLength_: %{public}d", parameterLength_);
1696
1697 PopOctets1((buffer + offset), payload);
1698 volume_ = static_cast<uint8_t>(payload) & 0b01111111;
1699 HILOGI("volume_: %{public}x", volume_);
1700
1701 isValid_ = true;
1702
1703 return isValid_;
1704 }
1705 } // namespace bluetooth
1706 } // namespace OHOS
1707