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 #include <algorithm>
16 #include "avrcp_tg_vendor.h"
17 #include "avrcp_tg_vendor_continuation.h"
18 #include "avrcp_tg_vendor_player_application_settings.h"
19
20 namespace OHOS {
21 namespace bluetooth {
22 /******************************************************************
23 * AvrcTgVendorPacket *
24 ******************************************************************/
25
AvrcTgVendorPacket()26 AvrcTgVendorPacket::AvrcTgVendorPacket() : AvrcTgPacket(), status_(AVRC_ES_CODE_INVALID), label_(AVRC_INVALID_LABEL)
27 {
28 HILOGI("enter");
29 }
30
AvrcTgVendorPacket(uint8_t pduId,uint8_t status,uint8_t label)31 AvrcTgVendorPacket::AvrcTgVendorPacket(uint8_t pduId, uint8_t status, uint8_t label) : status_(status), label_(label)
32 {
33 HILOGI("pduId:%{public}d, status:%{public}d, label:%{public}d", pduId, status, label);
34
35 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
36 pduId_ = pduId;
37 status_ = status;
38 label_ = label;
39
40 AssembleRejectPacket();
41 }
42
~AvrcTgVendorPacket()43 AvrcTgVendorPacket::~AvrcTgVendorPacket()
44 {
45 HILOGI("enter");
46
47 for (auto &pkt : pkts_) {
48 PacketFree(pkt);
49 pkt = nullptr;
50 }
51 pkts_.clear();
52 }
53
AssembleParameters(Packet * pkt)54 Packet *AvrcTgVendorPacket::AssembleParameters(Packet *pkt)
55 {
56 HILOGI("enter");
57
58 return nullptr;
59 }
60
AssemblePacket(void)61 const Packet *AvrcTgVendorPacket::AssemblePacket(void)
62 {
63 HILOGI("enter");
64
65 return nullptr;
66 }
67
AssemblePackets(void)68 void AvrcTgVendorPacket::AssemblePackets(void)
69 {
70 HILOGI("enter");
71
72 Packet *pkt = AssembleRejectPacket();
73 if (pkt != nullptr) {
74 return;
75 }
76
77 /// Calculates the number of packets.
78 uint16_t numOfPkts = GetNumberOfPackets();
79 if (numOfPkts == 0x00) {
80 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
81 AssembleRejectPacket();
82 return;
83 }
84
85 for (int i = 0; i < numOfPkts; i++) {
86 pkt = AssembleMinOperands();
87
88 if (numOfPkts == 1) {
89 packetType_ = AVRC_TG_VENDOR_PACKET_TYPE;
90 } else if (i == 0) {
91 packetType_ = AVRC_TG_VENDOR_PACKET_TYPE_START;
92 } else if (i == numOfPkts - 1) {
93 packetType_ = AVRC_TG_VENDOR_PACKET_TYPE_END;
94 } else {
95 packetType_ = AVRC_TG_VENDOR_PACKET_TYPE_CONTINUE;
96 }
97
98 pkt = AssembleParameters(pkt);
99 pkts_.push_back(pkt);
100 }
101 }
102
DisassemblePacket(Packet * pkt)103 bool AvrcTgVendorPacket::DisassemblePacket(Packet *pkt)
104 {
105 HILOGI("enter");
106
107 isValid_ = IsValidParameterLength(pkt);
108 if (isValid_) {
109 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
110 ASSERT(buffer != nullptr);
111 uint16_t offset = AVRC_TG_VENDOR_CTYPE_OFFSET;
112 uint64_t payload = 0x00;
113 PopOctets1((buffer + offset), payload);
114 crCode_ = static_cast<uint8_t>(payload);
115 HILOGI("crCode_: %{public}x", crCode_);
116
117 offset = AVRC_TG_VENDOR_COMPANY_ID_OFFSET;
118 payload = 0x00;
119 PopOctets3((buffer + offset), payload);
120 companyId_ = static_cast<uint32_t>(payload);
121 HILOGI("companyId_: %{public}x", companyId_);
122
123 offset = AVRC_TG_VENDOR_PACKET_TYPE_OFFSET;
124 payload = 0x00;
125 PopOctets1((buffer + offset), payload);
126 packetType_ = static_cast<uint8_t>(payload);
127 HILOGI("packetType_: %{public}x", packetType_);
128
129 isValid_ = DisassembleParameters(buffer);
130 } else {
131 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
132 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
133 AssembleRejectPacket();
134 }
135
136 return isValid_;
137 }
138
DisassembleParameters(uint8_t * buffer)139 bool AvrcTgVendorPacket::DisassembleParameters(uint8_t *buffer)
140 {
141 HILOGI("enter");
142
143 return false;
144 }
145
GetNumberOfPackets(void)146 uint16_t AvrcTgVendorPacket::GetNumberOfPackets(void)
147 {
148 HILOGI("enter");
149
150 return AVRC_TG_VENDOR_PACKET_TYPE;
151 }
152
PopAssembledPacket(void)153 Packet *AvrcTgVendorPacket::PopAssembledPacket(void)
154 {
155 HILOGI("enter");
156
157 Packet *pkt = nullptr;
158
159 if (pkts_.size() > 0) {
160 pkt = pkts_.front();
161 pkts_.pop_front();
162 }
163
164 HILOGI("pkts_.size: %{public}zu", pkts_.size());
165
166 return pkt;
167 }
168
AssembleRejectPacket(void)169 Packet *AvrcTgVendorPacket::AssembleRejectPacket(void)
170 {
171 HILOGI("enter");
172
173 Packet *pkt = nullptr;
174
175 if ((crCode_ == AVRC_TG_RSP_CODE_REJECTED) || (crCode_ == AVRC_TG_RSP_CODE_NOT_IMPLEMENTED)) {
176 size_t size = AVRC_TG_VENDOR_FIXED_OPERAND_SIZE;
177
178 size += AVRC_TG_VENDOR_ERROR_CODE_SIZE;
179 parameterLength_ = AVRC_TG_VENDOR_ERROR_CODE_SIZE;
180
181 if (status_ == AVRC_ES_CODE_INVALID) {
182 status_ = AVRC_ES_CODE_INTERNAL_ERROR;
183 }
184
185 pkt = PacketMalloc(0x00, 0x00, size);
186 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
187 ASSERT(buffer != nullptr);
188 uint16_t offset = 0x00;
189 offset += PushOctets1((buffer + offset), crCode_);
190 HILOGI("crCode_: %{public}x", crCode_);
191
192 offset += PushOctets1((buffer + offset), (subunitType_ << AVRC_TG_VENDOR_BIT3) | subunitId_);
193 HILOGI("subunitType_: %{public}x, subunitId_: %{public}x", subunitType_, subunitId_);
194
195 offset += PushOctets1((buffer + offset), opCode_);
196 HILOGI("opCode_: %{public}x", opCode_);
197
198 offset += PushOctets3((buffer + offset), companyId_);
199 HILOGI("companyId_: %{public}x", companyId_);
200
201 offset += PushOctets1((buffer + offset), pduId_);
202 HILOGI("pduId_: %{public}x", pduId_);
203
204 offset += PushOctets1((buffer + offset), packetType_);
205 HILOGI("packetType_: %{public}x", packetType_);
206
207 offset += PushOctets2((buffer + offset), parameterLength_);
208 HILOGI("parameterLength_: %{public}u", parameterLength_);
209
210 PushOctets1((buffer + offset), status_);
211 HILOGI("status_: %{public}x", status_);
212
213 pkts_.push_back(pkt);
214 }
215
216 return pkt;
217 }
218
AssembleMinOperands(void)219 Packet *AvrcTgVendorPacket::AssembleMinOperands(void)
220 {
221 HILOGI("enter");
222
223 Packet *pkt = PacketMalloc(0x00, 0x00, AVRC_TG_VENDOR_MIN_COMMAND_SIZE);
224 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
225 ASSERT(buffer != nullptr);
226
227 uint16_t offset = 0x00;
228 offset += PushOctets1((buffer + offset), crCode_);
229 HILOGI("crCode_: %{public}x", crCode_);
230
231 offset += PushOctets1((buffer + offset), (subunitType_ << AVRC_TG_VENDOR_BIT3) | subunitId_);
232 HILOGI("subunitType_: %{public}x, subunitId_: %{public}x", subunitType_, subunitId_);
233
234 offset += PushOctets1((buffer + offset), opCode_);
235 HILOGI("opCode_: %{public}x", opCode_);
236
237 offset += PushOctets3((buffer + offset), companyId_);
238 HILOGI("companyId_: %{public}x", companyId_);
239
240 PushOctets1((buffer + offset), pduId_);
241 HILOGI("pduId_: %{public}x", pduId_);
242
243 return pkt;
244 }
245
IsValidParameterLength(Packet * pkt)246 bool AvrcTgVendorPacket::IsValidParameterLength(Packet *pkt)
247 {
248 HILOGI("enter");
249
250 bool result = false;
251
252 size_t size = PacketPayloadSize(pkt);
253 if (size >= AVRC_TG_VENDOR_FIXED_OPERAND_SIZE) {
254 auto buffer = static_cast<uint8_t *>(BufferPtr(PacketContinuousPayload(pkt)));
255 ASSERT(buffer != nullptr);
256
257 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
258 uint64_t payload = 0x00;
259 PopOctets2((buffer + offset), payload);
260 parameterLength_ = static_cast<uint32_t>(payload);
261 HILOGI("parameterLength_: %{public}d", parameterLength_);
262
263 if (size - AVRC_TG_VENDOR_FIXED_OPERAND_SIZE == parameterLength_) {
264 result = true;
265 }
266 } else {
267 HILOGI("The size of the packet is invalid! - actual size: %{public}zu valid min size: %{public}jx",
268 size, AVRC_TG_VENDOR_FIXED_OPERAND_SIZE);
269 }
270
271 return result;
272 }
273
274 /******************************************************************
275 * GetCapability *
276 ******************************************************************/
277
AvrcTgGcPacket(uint8_t crCode,const std::vector<uint32_t> & companies,uint8_t label)278 AvrcTgGcPacket::AvrcTgGcPacket(uint8_t crCode, const std::vector<uint32_t> &companies, uint8_t label)
279 : AvrcTgVendorPacket()
280 {
281 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
282
283 crCode_ = crCode;
284 pduId_ = AVRC_TG_PDU_ID_GET_CAPABILITIES;
285 capabilityId_ = AVRC_TG_GC_CAPABILITY_COMPANY;
286 label_ = label;
287 companies_ = companies;
288
289 AssemblePackets();
290 }
291
AvrcTgGcPacket(uint8_t crCode,const std::vector<uint8_t> & events,uint8_t label)292 AvrcTgGcPacket::AvrcTgGcPacket(uint8_t crCode, const std::vector<uint8_t> &events, uint8_t label) : AvrcTgVendorPacket()
293 {
294 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
295
296 crCode_ = crCode;
297 pduId_ = AVRC_TG_PDU_ID_GET_CAPABILITIES;
298 capabilityId_ = AVRC_TG_GC_CAPABILITY_EVENT;
299 label_ = label;
300 events_ = events;
301
302 AssemblePackets();
303 }
304
AvrcTgGcPacket(Packet * pkt,uint8_t label)305 AvrcTgGcPacket::AvrcTgGcPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
306 {
307 HILOGI("label: %{public}d", label);
308
309 crCode_ = AVRC_TG_RSP_CODE_STABLE;
310 pduId_ = AVRC_TG_PDU_ID_GET_CAPABILITIES;
311 label_ = label;
312
313 DisassemblePacket(pkt);
314 }
315
~AvrcTgGcPacket()316 AvrcTgGcPacket ::~AvrcTgGcPacket()
317 {
318 HILOGI("enter");
319
320 companies_.clear();
321 events_.clear();
322 }
323
AssembleParameters(Packet * pkt)324 Packet *AvrcTgGcPacket::AssembleParameters(Packet *pkt)
325 {
326 HILOGI("enter");
327
328 if (capabilityId_ == AVRC_TG_GC_CAPABILITY_COMPANY) {
329 AssembleCompanies(pkt);
330 } else if (capabilityId_ == AVRC_TG_GC_CAPABILITY_EVENT) {
331 AssembleEvents(pkt);
332 } else {
333 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
334 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
335 AssembleRejectPacket();
336 }
337
338 return pkt;
339 }
340
DisassembleParameters(uint8_t * buffer)341 bool AvrcTgGcPacket::DisassembleParameters(uint8_t *buffer)
342 {
343 HILOGI("enter");
344
345 isValid_ = false;
346
347 do {
348 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
349 uint64_t payload = 0x00;
350 offset += PopOctets2((buffer + offset), payload);
351 parameterLength_ = static_cast<uint16_t>(payload);
352 HILOGI("parameterLength_: %{public}d", parameterLength_);
353
354 payload = 0x00;
355 PopOctets1((buffer + offset), payload);
356 capabilityId_ = static_cast<uint8_t>(payload);
357 HILOGI("capabilityId_: %{public}x", capabilityId_);
358 if (capabilityId_ != AVRC_TG_GC_CAPABILITY_COMPANY && capabilityId_ != AVRC_TG_GC_CAPABILITY_EVENT) {
359 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
360 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
361 AssembleRejectPacket();
362 break;
363 }
364
365 isValid_ = true;
366 HILOGI("isValid_: %{public}d", isValid_);
367 } while (false);
368
369 return isValid_;
370 }
371
GetNumberOfPackets(void)372 uint16_t AvrcTgGcPacket::GetNumberOfPackets(void)
373 {
374 HILOGI("enter");
375
376 uint16_t numOfPkts = AVRC_TG_VENDOR_NUM_OF_PACKETS;
377
378 if (companies_.size() > 0 || events_.size() > 0) {
379 numOfPkts = AVRC_TG_GC_NUM_OF_PACKETS;
380 } else {
381 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
382 }
383 HILOGI("numOfPkts: %{public}u", numOfPkts);
384
385 return numOfPkts;
386 }
387
AssembleCompanies(Packet * pkt)388 void AvrcTgGcPacket::AssembleCompanies(Packet *pkt)
389 {
390 HILOGI("enter");
391
392 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
393 AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_GC_COMPANY_PARA_LENGTH * companies_.size();
394 HILOGI("BufferMalloc: %{public}zu", bufferSize);
395
396 auto buffer = BufferMalloc(bufferSize);
397 if (buffer == nullptr) {
398 HILOGE("BufferMalloc fail");
399 return;
400 }
401 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
402
403 uint16_t offset = 0x0000;
404 offset += PushOctets1((bufferPtr + offset), packetType_);
405 HILOGI("packetType_: %{public}x", packetType_);
406
407 parameterLength_ = bufferSize - (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE);
408 offset += PushOctets2((bufferPtr + offset), parameterLength_);
409 HILOGI("parameterLength_: %{public}d", parameterLength_);
410
411 offset += PushOctets1((bufferPtr + offset), capabilityId_);
412 HILOGI("capabilityId_: %{public}x", capabilityId_);
413
414 capabilityCount_ = companies_.size();
415 offset += PushOctets1((bufferPtr + offset), capabilityCount_);
416 HILOGI("capabilityCount_: %{public}d", capabilityCount_);
417
418 for (auto company : companies_) {
419 offset += PushOctets3((bufferPtr + offset), company);
420 HILOGI("company: %{public}x", company);
421 }
422
423 PacketPayloadAddLast(pkt, buffer);
424
425 BufferFree(buffer);
426 buffer = nullptr;
427 bufferPtr = nullptr;
428 }
429
AssembleEvents(Packet * pkt)430 void AvrcTgGcPacket::AssembleEvents(Packet *pkt)
431 {
432 HILOGI("enter");
433
434 size_t bufferSize = (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
435 AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_GC_EVENT_PARA_LENGTH * events_.size());
436 HILOGI("BufferMalloc: %{public}zu", bufferSize);
437
438 auto buffer = BufferMalloc(bufferSize);
439 if (buffer == nullptr) {
440 HILOGE("BufferMalloc fail");
441 return;
442 }
443 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
444
445 uint16_t offset = 0x0000;
446
447 offset += PushOctets1((bufferPtr + offset), packetType_);
448 HILOGI("packetType_: %{public}x", packetType_);
449
450 parameterLength_ = bufferSize - (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE);
451 offset += PushOctets2((bufferPtr + offset), parameterLength_);
452 HILOGI("parameterLength_: %{public}d", parameterLength_);
453
454 offset += PushOctets1((bufferPtr + offset), capabilityId_);
455 HILOGI("capabilityId_: %{public}x", capabilityId_);
456
457 capabilityCount_ = events_.size();
458 offset += PushOctets1((bufferPtr + offset), capabilityCount_);
459 HILOGI("capabilityCount_: %{public}u", capabilityCount_);
460
461 for (auto event : events_) {
462 offset += PushOctets1((bufferPtr + offset), event);
463 HILOGI("event: %{public}x", event);
464 }
465
466 PacketPayloadAddLast(pkt, buffer);
467
468 BufferFree(buffer);
469 buffer = nullptr;
470 bufferPtr = nullptr;
471 }
472
473 /******************************************************************
474 * ListPlayerApplicationSettingAttributes *
475 ******************************************************************/
476
AvrcTgLpasaPacket(uint8_t crCode,const std::deque<uint8_t> & attributes,uint8_t label)477 AvrcTgLpasaPacket::AvrcTgLpasaPacket(uint8_t crCode, const std::deque<uint8_t> &attributes, uint8_t label)
478 : AvrcTgVendorPacket()
479 {
480 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
481
482 crCode_ = crCode;
483 pduId_ = AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES;
484 attributes_ = attributes;
485 label_ = label;
486
487 AssemblePackets();
488 }
489
AvrcTgLpasaPacket(Packet * pkt,uint8_t label)490 AvrcTgLpasaPacket::AvrcTgLpasaPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
491 {
492 HILOGI("label: %{public}d", label);
493
494 crCode_ = AVRC_TG_RSP_CODE_STABLE;
495 pduId_ = AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES;
496 label_ = label;
497
498 DisassemblePacket(pkt);
499 }
500
~AvrcTgLpasaPacket()501 AvrcTgLpasaPacket::~AvrcTgLpasaPacket()
502 {
503 HILOGI("enter");
504
505 attributes_.clear();
506 }
507
AssembleParameters(Packet * pkt)508 Packet *AvrcTgLpasaPacket::AssembleParameters(Packet *pkt)
509 {
510 HILOGI("enter");
511
512 numOfAttributes_ = attributes_.size();
513 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
514 AVRC_TG_LPASA_NUM_OF_ATTRIBUTES_SIZE + numOfAttributes_;
515 HILOGI("BufferMalloc: %{public}zu", bufferSize);
516
517 auto buffer = BufferMalloc(bufferSize);
518 if (buffer == nullptr) {
519 HILOGE("BufferMalloc fail");
520 return pkt;
521 }
522 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
523
524 uint16_t offset = 0x0000;
525 offset += PushOctets1((bufferPtr + offset), packetType_);
526 HILOGI("packetType_: %{public}x", packetType_);
527
528 parameterLength_ = numOfAttributes_ + AVRC_TG_LPASA_NUM_OF_ATTRIBUTES_SIZE;
529 offset += PushOctets2((bufferPtr + offset), parameterLength_);
530 HILOGI("parameterLength_: %{public}d", parameterLength_);
531
532 offset += PushOctets1((bufferPtr + offset), numOfAttributes_);
533 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
534
535 for (auto attribute : attributes_) {
536 offset += PushOctets1((bufferPtr + offset), attribute);
537 HILOGI("attribute: %{public}x", attribute);
538 }
539
540 PacketPayloadAddLast(pkt, buffer);
541
542 BufferFree(buffer);
543 buffer = nullptr;
544 bufferPtr = nullptr;
545
546 return pkt;
547 }
548
DisassembleParameters(uint8_t * buffer)549 bool AvrcTgLpasaPacket::DisassembleParameters(uint8_t *buffer)
550 {
551 HILOGI("enter");
552
553 isValid_ = true;
554
555 HILOGI("isValid_: %{public}d", isValid_);
556
557 return isValid_;
558 }
559
GetNumberOfPackets(void)560 uint16_t AvrcTgLpasaPacket::GetNumberOfPackets(void)
561 {
562 HILOGI("enter");
563
564 uint16_t numOfPkts = AVRC_TG_VENDOR_NUM_OF_PACKETS;
565
566 if (attributes_.size() > 0) {
567 numOfPkts = AVRC_TG_LPASA_NUM_OF_PACKETS;
568 } else {
569 status_ = AVRC_ES_CODE_INTERNAL_ERROR;
570 }
571 HILOGI("numOfPkts: %{public}d", numOfPkts);
572
573 return numOfPkts;
574 }
575
576 /******************************************************************
577 * ListPlayerApplicationSettingValues *
578 ******************************************************************/
579
AvrcTgLpasvPacket(uint8_t crCode,const std::deque<uint8_t> & values,uint8_t label)580 AvrcTgLpasvPacket::AvrcTgLpasvPacket(uint8_t crCode, const std::deque<uint8_t> &values, uint8_t label)
581 : AvrcTgVendorPacket()
582 {
583 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
584
585 crCode_ = crCode;
586 pduId_ = AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES;
587 values_ = values;
588 label_ = label;
589
590 AssemblePackets();
591 }
592
AvrcTgLpasvPacket(Packet * pkt,uint8_t label)593 AvrcTgLpasvPacket::AvrcTgLpasvPacket(Packet *pkt, uint8_t label)
594 : AvrcTgVendorPacket(), attribute_(AVRC_PLAYER_ATTRIBUTE_ILLEGAL)
595 {
596 HILOGI("label: %{public}d", label);
597
598 crCode_ = AVRC_TG_RSP_CODE_STABLE;
599 pduId_ = AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES;
600 label_ = label;
601
602 DisassemblePacket(pkt);
603 }
604
~AvrcTgLpasvPacket()605 AvrcTgLpasvPacket::~AvrcTgLpasvPacket()
606 {
607 HILOGI("enter");
608
609 values_.clear();
610 }
611
AssembleParameters(Packet * pkt)612 Packet *AvrcTgLpasvPacket::AssembleParameters(Packet *pkt)
613 {
614 HILOGI("enter");
615
616 if (GetNumberOfPackets() > 0) {
617 numOfValues_ = values_.size();
618 if (numOfValues_ > AVRC_TG_LPASV_MAX_NUM_OF_VALUES) {
619 numOfValues_ = AVRC_TG_LPASV_MAX_NUM_OF_VALUES;
620 }
621 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
622 AVRC_TG_LPASV_NUM_OF_VALUES_SIZE + numOfValues_;
623 HILOGI("BufferMalloc: %{public}zu", bufferSize);
624
625 auto buffer = BufferMalloc(bufferSize);
626 if (buffer == nullptr) {
627 HILOGE("BufferMalloc fail");
628 return pkt;
629 }
630 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
631
632 uint16_t offset = 0x0000;
633 offset += PushOctets1((bufferPtr + offset), packetType_);
634 HILOGI("packetType_: %{public}x", packetType_);
635
636 parameterLength_ = numOfValues_ + AVRC_TG_LPASV_NUM_OF_VALUES_SIZE;
637 offset += PushOctets2((bufferPtr + offset), parameterLength_);
638 HILOGI("parameterLength_: %{public}d", parameterLength_);
639
640 offset += PushOctets1((bufferPtr + offset), numOfValues_);
641 HILOGI("numOfValues_: %{public}d", numOfValues_);
642
643 for (uint16_t i = 0; i < numOfValues_; i++) {
644 offset += PushOctets1((bufferPtr + offset), values_.at(i));
645 HILOGI("value: %{public}x", values_.at(i));
646 }
647 HILOGI("before erase values_.size: %{public}zu", values_.size());
648 values_.erase(values_.begin(), values_.begin() + numOfValues_);
649 HILOGI("after erase values_.size: %{public}zu", values_.size());
650
651 PacketPayloadAddLast(pkt, buffer);
652
653 BufferFree(buffer);
654 buffer = nullptr;
655 bufferPtr = nullptr;
656 }
657
658 return pkt;
659 }
660
DisassembleParameters(uint8_t * buffer)661 bool AvrcTgLpasvPacket::DisassembleParameters(uint8_t *buffer)
662 {
663 HILOGI("enter");
664
665 isValid_ = false;
666
667 do {
668 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
669 uint64_t payload = 0x00;
670 offset += PopOctets2((buffer + offset), payload);
671 parameterLength_ = static_cast<uint8_t>(payload);
672 HILOGI("parameterLength_: %{public}d", parameterLength_);
673
674 payload = 0x00;
675 PopOctets1((buffer + offset), payload);
676 attribute_ = static_cast<uint8_t>(payload);
677 HILOGI("attribute_: %{public}x", attribute_);
678
679 if (!IsValidAttribute()) {
680 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
681 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
682 AssembleRejectPacket();
683 break;
684 }
685
686 isValid_ = true;
687 } while (false);
688
689 HILOGI("isValid_: %{public}d", isValid_);
690
691 return isValid_;
692 }
693
GetNumberOfPackets(void)694 uint16_t AvrcTgLpasvPacket::GetNumberOfPackets(void)
695 {
696 HILOGI("enter");
697
698 uint16_t numOfPkts = AVRC_TG_VENDOR_NUM_OF_PACKETS;
699
700 if (values_.size() > 0) {
701 double paramSize = values_.size();
702 numOfPkts = ceil(paramSize / AVRC_TG_LPASV_MAX_NUM_OF_VALUES);
703 } else {
704 status_ = AVRC_ES_CODE_INTERNAL_ERROR;
705 }
706 HILOGI("numOfPkts: %{public}d", numOfPkts);
707
708 return numOfPkts;
709 }
710
IsValidAttribute(void) const711 bool AvrcTgLpasvPacket::IsValidAttribute(void) const
712 {
713 HILOGI("enter");
714
715 bool result = false;
716
717 do {
718 if (attribute_ == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
719 break;
720 }
721
722 if (attribute_ >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN && attribute_ <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
723 break;
724 }
725
726 result = true;
727 } while (false);
728
729 HILOGI("result: %{public}d", result);
730
731 return result;
732 }
733
734 /******************************************************************
735 * GetCurrentPlayerApplicationSettingValue *
736 ******************************************************************/
737
AvrcTgGcpasvPacket(uint16_t mtu,uint8_t crCode,const std::deque<uint8_t> & attributes,const std::deque<uint8_t> & values,uint8_t label)738 AvrcTgGcpasvPacket::AvrcTgGcpasvPacket(uint16_t mtu, uint8_t crCode, const std::deque<uint8_t> &attributes,
739 const std::deque<uint8_t> &values, uint8_t label)
740 : AvrcTgVendorPacket()
741 {
742 HILOGI("mtu: %{public}d, crCode: %{public}d, label: %{public}d", mtu, crCode, label);
743
744 if (mtu > AVRC_TG_DEFAULT_CONTROL_MTU_SIZE) {
745 mtu_ = mtu;
746 }
747
748 crCode_ = crCode;
749 pduId_ = AVRC_TG_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE;
750 attributes_ = attributes;
751 values_ = values;
752 label_ = label;
753
754 AssemblePackets();
755 }
756
AvrcTgGcpasvPacket(Packet * pkt,uint8_t label)757 AvrcTgGcpasvPacket::AvrcTgGcpasvPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
758 {
759 HILOGI("label: %{public}d", label);
760
761 crCode_ = AVRC_TG_RSP_CODE_STABLE;
762 pduId_ = AVRC_TG_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE;
763 label_ = label;
764
765 DisassemblePacket(pkt);
766 }
767
~AvrcTgGcpasvPacket()768 AvrcTgGcpasvPacket::~AvrcTgGcpasvPacket()
769 {
770 HILOGI("enter");
771
772 attributes_.clear();
773 values_.clear();
774 }
775
AssembleParameters(Packet * pkt)776 Packet *AvrcTgGcpasvPacket::AssembleParameters(Packet *pkt)
777 {
778 HILOGI("enter");
779
780 if (GetNumberOfPackets() > 0) {
781 numOfValues_ = GetAvailableParameterSize() / AVRC_TG_LPASV_NUM_OF_VALUES_AND_ATTRIBUTE;
782 if (numOfValues_ > values_.size()) {
783 numOfValues_ = values_.size();
784 }
785 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
786 AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE + numOfValues_ + numOfValues_;
787 HILOGI("BufferMalloc: %{public}zu", bufferSize);
788
789 auto buffer = BufferMalloc(bufferSize);
790 if (buffer == nullptr) {
791 HILOGE("BufferMalloc fail");
792 return pkt;
793 }
794 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
795
796 uint16_t offset = 0x0000;
797 offset += PushOctets1((bufferPtr + offset), packetType_);
798 HILOGI("packetType_: %{public}x", packetType_);
799
800 parameterLength_ = numOfValues_ + numOfValues_ + AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE;
801 offset += PushOctets2((bufferPtr + offset), parameterLength_);
802 HILOGI("parameterLength_: %{public}d", parameterLength_);
803
804 offset += PushOctets1((bufferPtr + offset), numOfValues_);
805 HILOGI("numOfValues_: %{public}d", numOfValues_);
806
807 for (int i = 0; i < numOfValues_; i++) {
808 offset += PushOctets1((bufferPtr + offset), attributes_.at(i));
809 HILOGI("attribute: %{public}x", attributes_.at(i));
810 offset += PushOctets1((bufferPtr + offset), values_.at(i));
811 HILOGI("value: %{public}x", values_.at(i));
812 }
813
814 HILOGI("before erase attributes_.size: %{public}zu, values_.size: %{public}zu",
815 attributes_.size(), values_.size());
816 attributes_.erase(attributes_.begin(), attributes_.begin() + numOfValues_);
817 values_.erase(values_.begin(), values_.begin() + numOfValues_);
818 HILOGI("after erase attributes_.size: %{public}zu, values_.size: %{public}zu",
819 attributes_.size(), values_.size());
820
821 PacketPayloadAddLast(pkt, buffer);
822
823 BufferFree(buffer);
824 buffer = nullptr;
825 bufferPtr = nullptr;
826 }
827
828 return pkt;
829 }
830
DisassembleParameters(uint8_t * buffer)831 bool AvrcTgGcpasvPacket::DisassembleParameters(uint8_t *buffer)
832 {
833 HILOGI("enter");
834
835 isValid_ = false;
836
837 do {
838 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
839 uint64_t payload = 0x00;
840 offset += PopOctets2((buffer + offset), payload);
841 parameterLength_ = static_cast<uint8_t>(payload);
842 HILOGI("parameterLength_: %{public}u", parameterLength_);
843
844 payload = 0x00;
845 offset += PopOctets1((buffer + offset), payload);
846 numOfAttributes_ = static_cast<uint8_t>(payload);
847 HILOGI("numOfAttributes_: %{public}u", numOfAttributes_);
848
849 for (int i = 0; i < numOfAttributes_; i++) {
850 payload = 0x00;
851 offset += PopOctets1((buffer + offset), payload);
852 attributes_.push_back(static_cast<uint8_t>(payload));
853 HILOGI("attribute: %{public}u", attributes_.back());
854 }
855
856 if (!IsValidAttribute()) {
857 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
858 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
859 AssembleRejectPacket();
860 break;
861 }
862
863 isValid_ = true;
864 } while (false);
865
866 HILOGI("isValid_: %{public}d", isValid_);
867
868 return isValid_;
869 }
870
GetNumberOfPackets(void)871 uint16_t AvrcTgGcpasvPacket::GetNumberOfPackets(void)
872 {
873 HILOGI("enter");
874
875 uint16_t numOfPkts = AVRC_TG_VENDOR_NUM_OF_PACKETS;
876
877 if (values_.size() > 0) {
878 double paramSize = attributes_.size() + values_.size();
879 numOfPkts = ceil(paramSize / GetAvailableParameterSize());
880 } else {
881 crCode_ = AVRC_TG_RSP_CODE_NOT_IMPLEMENTED;
882 }
883
884 HILOGI("numOfPkts: %{public}hu", numOfPkts);
885
886 return numOfPkts;
887 }
888
GetAvailableParameterSize(void) const889 uint16_t AvrcTgGcpasvPacket::GetAvailableParameterSize(void) const
890 {
891 HILOGI("enter");
892
893 uint16_t remain = mtu_ - (AVRC_TG_VENDOR_FIXED_OPERAND_SIZE + AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE);
894 if (remain > (AVRC_TG_GCPASV_MAX_NUM_OF_ATTRIBUTES + AVRC_TG_GCPASV_MAX_NUM_OF_VALUES)) {
895 remain = (AVRC_TG_GCPASV_MAX_NUM_OF_ATTRIBUTES + AVRC_TG_GCPASV_MAX_NUM_OF_VALUES);
896 }
897 uint16_t unitsOfParam = AVRC_TG_GCPASV_ATTRIBUTE_SIZE + AVRC_TG_GCPASV_VALUE_SIZE;
898
899 return (remain / unitsOfParam) * unitsOfParam;
900 }
901
IsValidAttribute(void) const902 bool AvrcTgGcpasvPacket::IsValidAttribute(void) const
903 {
904 HILOGI("enter");
905
906 bool result = false;
907
908 for (auto attribute : attributes_) {
909 do {
910 if (attribute == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
911 break;
912 }
913
914 if ((attribute >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN)
915 && (attribute <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX)) {
916 break;
917 }
918
919 result = true;
920 } while (false);
921 }
922
923 HILOGI("result: %{public}d", result);
924
925 return result;
926 }
927
928 /******************************************************************
929 * SetPlayerApplicationSettingValue *
930 ******************************************************************/
931
AvrcTgSpasvPacket(uint8_t crCode,uint8_t label)932 AvrcTgSpasvPacket::AvrcTgSpasvPacket(uint8_t crCode, uint8_t label)
933 {
934 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
935
936 crCode_ = crCode;
937 pduId_ = AVRC_TG_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE;
938 label_ = label;
939
940 AssemblePackets();
941 }
942
AvrcTgSpasvPacket(Packet * pkt,uint8_t label)943 AvrcTgSpasvPacket::AvrcTgSpasvPacket(Packet *pkt, uint8_t label)
944 {
945 HILOGI("label: %{public}d", label);
946
947 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
948 pduId_ = AVRC_TG_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE;
949 label_ = label;
950
951 DisassemblePacket(pkt);
952 }
953
~AvrcTgSpasvPacket()954 AvrcTgSpasvPacket::~AvrcTgSpasvPacket()
955 {
956 HILOGI("enter");
957 }
958
AssembleParameters(Packet * pkt)959 Packet *AvrcTgSpasvPacket::AssembleParameters(Packet *pkt)
960 {
961 HILOGI("enter");
962
963 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE;
964 HILOGI("BufferMalloc: %{public}zu", bufferSize);
965
966 auto buffer = BufferMalloc(bufferSize);
967 if (buffer == nullptr) {
968 HILOGE("BufferMalloc fail");
969 return pkt;
970 }
971 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
972
973 uint16_t offset = 0x0000;
974 offset += PushOctets1((bufferPtr + offset), packetType_);
975 HILOGI("packetType_: %{public}x", packetType_);
976
977 PushOctets2((bufferPtr + offset), parameterLength_);
978 HILOGI("parameterLength_: %{public}d", parameterLength_);
979
980 PacketPayloadAddLast(pkt, buffer);
981
982 BufferFree(buffer);
983
984 return pkt;
985 }
986
DisassembleParameters(uint8_t * buffer)987 bool AvrcTgSpasvPacket::DisassembleParameters(uint8_t *buffer)
988 {
989 HILOGI("enter");
990
991 isValid_ = false;
992
993 do {
994 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
995 uint64_t payload = 0x00;
996 offset += PopOctets2((buffer + offset), payload);
997 parameterLength_ = static_cast<uint8_t>(payload);
998 HILOGI("parameterLength_: %{public}d", parameterLength_);
999
1000 payload = 0x00;
1001 offset += PopOctets1((buffer + offset), payload);
1002 numOfAttributes_ = static_cast<uint8_t>(payload);
1003 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
1004
1005 for (int i = 0; i < numOfAttributes_; i++) {
1006 payload = 0x00;
1007 offset += PopOctets1((buffer + offset), payload);
1008 attributes_.push_back(static_cast<uint8_t>(payload));
1009 HILOGI("attribute: %{public}x", attributes_.back());
1010
1011 payload = 0x00;
1012 offset += PopOctets1((buffer + offset), payload);
1013 values_.push_back(static_cast<uint8_t>(payload));
1014 HILOGI("value: %{public}x", values_.back());
1015 }
1016
1017 if (!IsValidAttributeAndValue()) {
1018 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
1019 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
1020 AssembleRejectPacket();
1021 break;
1022 }
1023
1024 isValid_ = true;
1025 } while (false);
1026
1027 HILOGI("isValid_: %{public}d", isValid_);
1028
1029 return isValid_;
1030 }
1031
GetNumberOfPackets(void)1032 uint16_t AvrcTgSpasvPacket::GetNumberOfPackets(void)
1033 {
1034 HILOGI("enter");
1035
1036 return AVRC_TG_SPASV_NUM_OF_PACKETS;
1037 }
1038
IsValidAttributeAndValue(void) const1039 bool AvrcTgSpasvPacket::IsValidAttributeAndValue(void) const
1040 {
1041 HILOGI("enter");
1042
1043 bool result = false;
1044
1045 for (size_t i = 0; i < attributes_.size(); i++) {
1046 do {
1047 if (attributes_.at(i) == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
1048 break;
1049 }
1050
1051 if (attributes_.at(i) >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN &&
1052 attributes_.at(i) <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
1053 break;
1054 }
1055
1056 if (values_.at(i) >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN &&
1057 values_.at(i) <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
1058 break;
1059 }
1060
1061 if (attributes_.at(i) == AVRC_PLAYER_ATTRIBUTE_EQUALIZER &&
1062 (values_.at(i) < AVRC_EQUALIZER_OFF || values_.at(i) > AVRC_EQUALIZER_ON)) {
1063 break;
1064 }
1065
1066 if (attributes_.at(i) == AVRC_PLAYER_ATTRIBUTE_REPEAT &&
1067 (values_.at(i) < AVRC_REPEAT_OFF || values_.at(i) > AVRC_REPEAT_GROUP)) {
1068 break;
1069 }
1070
1071 if (attributes_.at(i) == AVRC_PLAYER_ATTRIBUTE_SHUFFLE &&
1072 (values_.at(i) < AVRC_SHUFFLE_OFF || values_.at(i) > AVRC_SHUFFLE_GROUP)) {
1073 break;
1074 }
1075
1076 if (attributes_.at(i) == AVRC_PLAYER_ATTRIBUTE_SCAN &&
1077 (values_.at(i) < AVRC_SCAN_OFF || values_.at(i) > AVRC_SCAN_GROUP)) {
1078 break;
1079 }
1080
1081 result = true;
1082 } while (false);
1083 }
1084
1085 HILOGI("result: %{public}d", result);
1086
1087 return result;
1088 }
1089
1090 /******************************************************************
1091 * GetPlayerApplicationSettingAttributeText *
1092 ******************************************************************/
1093
AvrcTgGpasatPacket(uint8_t crCode,const std::vector<uint8_t> & attributes,const std::vector<std::string> & attrName,uint8_t label)1094 AvrcTgGpasatPacket::AvrcTgGpasatPacket(
1095 uint8_t crCode, const std::vector<uint8_t> &attributes, const std::vector<std::string> &attrName, uint8_t label)
1096 {
1097 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
1098
1099 pduId_ = AVRC_TG_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT;
1100 crCode_ = crCode;
1101 attributes_ = attributes;
1102 attributeName_ = attrName;
1103 numOfAttributes_ = attributes.size();
1104 HILOGI("numOfAttributes_: %{public}d", numOfAttributes_);
1105 label_ = label;
1106
1107 AssemblePackets();
1108 }
1109
AvrcTgGpasatPacket(Packet * pkt,uint8_t label)1110 AvrcTgGpasatPacket::AvrcTgGpasatPacket(Packet *pkt, uint8_t label)
1111 {
1112 HILOGI("label: %{public}d", label);
1113
1114 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1115 pduId_ = AVRC_TG_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT;
1116 label_ = label;
1117
1118 DisassemblePacket(pkt);
1119 }
1120
~AvrcTgGpasatPacket()1121 AvrcTgGpasatPacket ::~AvrcTgGpasatPacket()
1122 {
1123 HILOGI("enter");
1124
1125 attributes_.clear();
1126 attributeName_.clear();
1127 }
1128
AssembleParameters(Packet * pkt)1129 Packet *AvrcTgGpasatPacket ::AssembleParameters(Packet *pkt)
1130 {
1131 HILOGI("enter");
1132
1133 if (packetPos_.size() > 0) {
1134 number_ = packetPos_.front().first;
1135 parameterLength_ = packetPos_.front().second + AVRC_TG_GPASAT_ATTRIBUTE_NUM_LENGTH;
1136 }
1137 size_t bufferSize = parameterLength_ + AVRC_TG_GPASAT_PARAMETER_LENGTH_SIZE;
1138 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1139 auto buffer = BufferMalloc(bufferSize);
1140 if (buffer == nullptr) {
1141 HILOGE("BufferMalloc fail");
1142 return pkt;
1143 }
1144 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1145
1146 uint16_t offset = 0x0000;
1147 offset += PushOctets1((bufferPtr + offset), packetType_);
1148 HILOGI("packetType_: %{public}d", packetType_);
1149 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1150 HILOGI("parameterLength_: %{public}d", parameterLength_);
1151 offset += PushOctets1((bufferPtr + offset), number_);
1152 HILOGI("number_: %{public}d", number_);
1153 for (int i = 0; i < number_; i++) {
1154 offset += PushOctets1((bufferPtr + offset), attributes_.at(i));
1155 offset += PushOctets2((bufferPtr + offset), static_cast<uint16_t>(AVRC_MEDIA_CHARACTER_SET_UTF8));
1156 offset += PushOctets1((bufferPtr + offset), attributeName_.at(i).length());
1157 for (auto it = attributeName_.at(i).begin(); it != attributeName_.at(i).end(); it++) {
1158 offset += PushOctets1((bufferPtr + offset), *it);
1159 }
1160 HILOGI("attributeName_: %{public}s", attributeName_.at(i).c_str());
1161 }
1162 HILOGI("values_.size: %{public}zu", attributeName_.size());
1163 attributes_.erase(attributes_.begin(), attributes_.begin() + number_);
1164 attributeName_.erase(attributeName_.begin(), attributeName_.begin() + number_);
1165 packetPos_.pop_front();
1166
1167 PacketPayloadAddLast(pkt, buffer);
1168
1169 BufferFree(buffer);
1170 buffer = nullptr;
1171 bufferPtr = nullptr;
1172
1173 return pkt;
1174 }
1175
DisassembleParameters(uint8_t * buffer)1176 bool AvrcTgGpasatPacket::DisassembleParameters(uint8_t *buffer)
1177 {
1178 HILOGI("enter");
1179
1180 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
1181 uint64_t payload = 0x00;
1182 offset += PopOctets2((buffer + offset), payload);
1183 parameterLength_ = static_cast<uint16_t>(payload);
1184 HILOGI("parameterLength_: %{public}d", parameterLength_);
1185
1186 payload = 0x00;
1187 offset += PopOctets1((buffer + offset), payload);
1188 number_ = static_cast<uint8_t>(payload);
1189 HILOGI("number_: %{public}x", number_);
1190
1191 for (int i = 0; i < number_; i++) {
1192 payload = 0x00;
1193 offset += PopOctets1((buffer + offset), payload);
1194 attributes_.push_back(static_cast<uint8_t>(payload));
1195 HILOGI("attribute: %{public}d", attributes_.at(i));
1196 }
1197 isValid_ = true;
1198 for (auto attribute : attributes_) {
1199 auto result = IsValidAttribute(attribute);
1200 if (!result) {
1201 isValid_ = false;
1202 break;
1203 }
1204 }
1205 if (!isValid_) {
1206 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
1207 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
1208 AssembleRejectPacket();
1209 }
1210
1211 HILOGI("isValid_: %{public}d", isValid_);
1212
1213 return isValid_;
1214 }
1215
GetNumberOfPackets(void)1216 uint16_t AvrcTgGpasatPacket::GetNumberOfPackets(void)
1217 {
1218 HILOGI("enter");
1219 uint16_t totalLength = 0x00;
1220 uint8_t totalNumber = 0x00;
1221 int packetNum = 1;
1222 std::pair<uint16_t, uint16_t> tem;
1223 for (int i = 0; i < numOfAttributes_; i++) {
1224 if (totalLength + attributeName_[i].length() + AVRC_TG_GPASAT_PARAMETER_EXCEPT_ATTRIBUTE_NUM <
1225 AVRC_TG_GPASAT_ASSEMBLE_MAX_SIZE) {
1226 totalLength += (attributeName_[i].length() + AVRC_TG_GPASAT_PARAMETER_EXCEPT_ATTRIBUTE_NUM);
1227 totalNumber++;
1228 } else {
1229 packetNum++;
1230 i--;
1231 tem = std::make_pair(totalNumber, totalLength);
1232 packetPos_.push_back(tem);
1233 totalLength = 0x00;
1234 totalNumber = 0x00;
1235 }
1236 }
1237 if (packetNum == 1 || totalNumber != 0) {
1238 tem = std::make_pair(totalNumber, totalLength);
1239 packetPos_.push_back(tem);
1240 }
1241 HILOGI("packetNum: %{public}x", packetNum);
1242
1243 return packetNum;
1244 }
1245
IsValidAttribute(uint8_t attribute)1246 bool AvrcTgGpasatPacket::IsValidAttribute(uint8_t attribute)
1247 {
1248 HILOGI("attribute: %{public}d", attribute);
1249
1250 bool result = false;
1251
1252 do {
1253 if (attribute == AVRC_PLAYER_ATTRIBUTE_ILLEGAL) {
1254 break;
1255 }
1256
1257 if (attribute >= AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN && attribute <= AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
1258 break;
1259 }
1260
1261 result = true;
1262 } while (false);
1263
1264 HILOGI("result: %{public}d", result);
1265
1266 return result;
1267 }
1268
1269 /******************************************************************
1270 * GetPlayerApplicationSettingValueText *
1271 ******************************************************************/
1272
AvrcTgGpasvtPacket(uint8_t crCode,const std::vector<uint8_t> & values,const std::vector<std::string> & valueName,uint8_t label)1273 AvrcTgGpasvtPacket::AvrcTgGpasvtPacket(
1274 uint8_t crCode, const std::vector<uint8_t> &values, const std::vector<std::string> &valueName, uint8_t label)
1275 {
1276 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
1277
1278 pduId_ = AVRC_TG_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT;
1279 crCode_ = crCode;
1280 values_ = values;
1281 valueName_ = valueName;
1282 numOfValues_ = values.size();
1283 label_ = label;
1284
1285 AssemblePackets();
1286 }
1287
AvrcTgGpasvtPacket(Packet * pkt,uint8_t label)1288 AvrcTgGpasvtPacket::AvrcTgGpasvtPacket(Packet *pkt, uint8_t label)
1289 {
1290 HILOGI("label: %{public}d", label);
1291
1292 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1293 pduId_ = AVRC_TG_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT;
1294 label_ = label;
1295
1296 DisassemblePacket(pkt);
1297 }
1298
~AvrcTgGpasvtPacket()1299 AvrcTgGpasvtPacket ::~AvrcTgGpasvtPacket()
1300 {
1301 HILOGI("enter");
1302
1303 values_.clear();
1304 valueName_.clear();
1305 }
1306
AssembleParameters(Packet * pkt)1307 Packet *AvrcTgGpasvtPacket ::AssembleParameters(Packet *pkt)
1308 {
1309 HILOGI("enter");
1310
1311 if (packetPos_.size() > 0) {
1312 number_ = packetPos_.front().first;
1313 parameterLength_ = packetPos_.front().second + AVRC_TG_GPASVT_NUM_OF_ATTRIBUTE_SIZE;
1314 }
1315
1316 size_t bufferSize = parameterLength_ + AVRC_TG_GPASVT_PARAMETER_LENGTH_SIZE;
1317 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1318 auto buffer = BufferMalloc(bufferSize);
1319 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1320
1321 uint16_t offset = 0x0000;
1322 offset += PushOctets1((bufferPtr + offset), packetType_);
1323 HILOGI("packetType_: %{public}d", packetType_);
1324 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1325 HILOGI("parameterLength_: %{public}d", parameterLength_);
1326 offset += PushOctets1((bufferPtr + offset), number_);
1327 HILOGI("number_: %{public}d", number_);
1328 for (int i = 0; i < number_; i++) {
1329 offset += PushOctets1((bufferPtr + offset), values_.at(i));
1330 offset += PushOctets2((bufferPtr + offset), static_cast<uint16_t>(AVRC_MEDIA_CHARACTER_SET_UTF8));
1331 offset += PushOctets1((bufferPtr + offset), valueName_.at(i).length());
1332 for (auto it = valueName_.at(i).begin(); it != valueName_.at(i).end(); it++) {
1333 offset += PushOctets1((bufferPtr + offset), *it);
1334 }
1335 HILOGI("valueName_: %{public}s", valueName_.at(i).c_str());
1336 }
1337 HILOGI("values_.size: %{public}zu", valueName_.size());
1338 values_.erase(values_.begin(), values_.begin() + number_);
1339 valueName_.erase(valueName_.begin(), valueName_.begin() + number_);
1340 packetPos_.pop_front();
1341
1342 PacketPayloadAddLast(pkt, buffer);
1343
1344 BufferFree(buffer);
1345 buffer = nullptr;
1346 bufferPtr = nullptr;
1347
1348 return pkt;
1349 }
1350
DisassembleParameters(uint8_t * buffer)1351 bool AvrcTgGpasvtPacket::DisassembleParameters(uint8_t *buffer)
1352 {
1353 HILOGI("enter");
1354 do {
1355 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
1356 uint64_t payload = 0x00;
1357 offset += PopOctets2((buffer + offset), payload);
1358 parameterLength_ = static_cast<uint16_t>(payload);
1359 HILOGI("parameterLength_: %{public}d", parameterLength_);
1360 payload = 0x00;
1361 offset += PopOctets1((buffer + offset), payload);
1362 attributeId_ = static_cast<uint8_t>(payload);
1363 HILOGI("attributeId_: %{public}d", attributeId_);
1364
1365 payload = 0x00;
1366 offset += PopOctets1((buffer + offset), payload);
1367 number_ = static_cast<uint8_t>(payload);
1368 HILOGI("number_: %{public}x", number_);
1369
1370 for (int i = 0; i < number_; i++) {
1371 payload = 0x00;
1372 offset += PopOctets1((buffer + offset), payload);
1373 values_.push_back(static_cast<uint8_t>(payload));
1374 HILOGI("value: %{public}x", values_.at(i));
1375 }
1376 if (!IsValidAttributeAndValue()) {
1377 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
1378 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
1379 AssembleRejectPacket();
1380 isValid_ = false;
1381 break;
1382 }
1383 isValid_ = true;
1384 } while (false);
1385
1386 HILOGI("isValid_: %{public}d", isValid_);
1387
1388 return isValid_;
1389 }
1390
GetNumberOfPackets(void)1391 uint16_t AvrcTgGpasvtPacket::GetNumberOfPackets(void)
1392 {
1393 HILOGI("enter");
1394
1395 uint16_t totalLength = 0x00;
1396 uint8_t totalNumber = 0x00;
1397 int packetNum = 1;
1398 std::pair<uint16_t, uint16_t> tem;
1399 for (int i = 0; i < numOfValues_; i++) {
1400 if (totalLength + valueName_[i].length() + AVRC_TG_GPASVT_PARAMETER_EXCEPT_ATTRIBUTE_NUM <
1401 AVRC_TG_GPASVT_ASSEMBLE_MAX_SIZE) {
1402 totalLength += (valueName_[i].length() + AVRC_TG_GPASVT_PARAMETER_EXCEPT_ATTRIBUTE_NUM);
1403 totalNumber++;
1404 } else {
1405 packetNum++;
1406 i--;
1407 tem = std::make_pair(totalNumber, totalLength);
1408 packetPos_.push_back(tem);
1409 totalLength = 0x00;
1410 totalNumber = 0x00;
1411 }
1412 }
1413 if (packetNum == 1 || totalNumber != 0) {
1414 tem = std::make_pair(totalNumber, totalLength);
1415 packetPos_.push_back(tem);
1416 }
1417
1418 HILOGI("packetNum: %{public}x", packetNum);
1419
1420 return packetNum;
1421 }
1422
IsValidAttributeAndValue(void) const1423 bool AvrcTgGpasvtPacket::IsValidAttributeAndValue(void) const
1424 {
1425 HILOGI("enter");
1426
1427 bool result = true;
1428
1429 switch (attributeId_) {
1430 case AVRC_PLAYER_ATTRIBUTE_EQUALIZER:
1431 if (any_of(values_.begin(), values_.end(),
1432 [](int value){return (value < AVRC_EQUALIZER_OFF || value > AVRC_EQUALIZER_ON);})){
1433 result = false;
1434 }
1435 break;
1436 case AVRC_PLAYER_ATTRIBUTE_REPEAT:
1437 if (any_of(values_.begin(), values_.end(),
1438 [](int value){return (value < AVRC_REPEAT_OFF || value > AVRC_REPEAT_GROUP);})){
1439 result = false;
1440 }
1441 break;
1442 case AVRC_PLAYER_ATTRIBUTE_SHUFFLE:
1443 if (any_of(values_.begin(), values_.end(),
1444 [](int value){return (value < AVRC_SHUFFLE_OFF || value > AVRC_SHUFFLE_GROUP);})){
1445 result = false;
1446 }
1447 break;
1448 case AVRC_PLAYER_ATTRIBUTE_SCAN:
1449 if (any_of(values_.begin(), values_.end(),
1450 [](int value){return (value < AVRC_SCAN_OFF || value > AVRC_SCAN_GROUP);})){
1451 result = false;
1452 }
1453 break;
1454 default:
1455 if (attributeId_ > AVRC_PLAYER_ATTRIBUTE_RESERVED_MIN &&
1456 attributeId_ < AVRC_PLAYER_ATTRIBUTE_RESERVED_MAX) {
1457 result = false;
1458 }
1459
1460 break;
1461 };
1462
1463 HILOGI("result: %{public}d", result);
1464
1465 return result;
1466 }
1467
1468 /******************************************************************
1469 * GetElementAttributePacket *
1470 ******************************************************************/
1471
AvrcTgGeaPacket(uint8_t crCode,const std::vector<uint32_t> & attribtues,const std::vector<std::string> & values,uint8_t label)1472 AvrcTgGeaPacket::AvrcTgGeaPacket(
1473 uint8_t crCode, const std::vector<uint32_t> &attribtues, const std::vector<std::string> &values, uint8_t label)
1474 {
1475 HILOGI("crCode: %{public}d, label: %{public}d", crCode, label);
1476
1477 crCode_ = crCode;
1478 pduId_ = AVRC_TG_PDU_ID_GET_ELEMENT_ATTRIBUTES;
1479 attributes_ = attribtues;
1480 values_ = values;
1481 numOfValues_ = values.size();
1482 label_ = label;
1483
1484 AssemblePackets();
1485 }
1486
AvrcTgGeaPacket(Packet * pkt,uint8_t label)1487 AvrcTgGeaPacket::AvrcTgGeaPacket(Packet *pkt, uint8_t label)
1488 {
1489 HILOGI("label: %{public}d", label);
1490
1491 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1492 pduId_ = AVRC_TG_PDU_ID_GET_ELEMENT_ATTRIBUTES;
1493 label_ = label;
1494
1495 DisassemblePacket(pkt);
1496 }
1497
~AvrcTgGeaPacket()1498 AvrcTgGeaPacket::~AvrcTgGeaPacket()
1499 {
1500 HILOGI("enter");
1501
1502 values_.clear();
1503 attributes_.clear();
1504 packetPos_.clear();
1505 }
1506
AssembleParameters(Packet * pkt)1507 Packet *AvrcTgGeaPacket::AssembleParameters(Packet *pkt)
1508 {
1509 HILOGI("enter");
1510 if (packetPos_.size() > 0) {
1511 number_ = packetPos_.front().first;
1512 parameterLength_ = packetPos_.front().second + AVRC_TG_GEA_SIZE_OF_ATTRIBUTE_LENGTH;
1513 }
1514
1515 size_t bufferSize = parameterLength_ + AVRC_TG_GEA_PARAMETER_LENGTH_SIZE;
1516 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1517 auto buffer = BufferMalloc(bufferSize);
1518 if (buffer == nullptr) {
1519 HILOGE("BufferMalloc fail");
1520 return pkt;
1521 }
1522 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1523
1524 uint16_t offset = 0x0000;
1525 offset += PushOctets1((bufferPtr + offset), packetType_);
1526 HILOGI("packetType_: %{public}x", packetType_);
1527
1528 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1529 HILOGI("parameterLength_: %{public}d", parameterLength_);
1530
1531 offset += PushOctets1((bufferPtr + offset), number_);
1532 HILOGI("number_: %{public}d", number_);
1533
1534 for (int i = 0; i < number_; i++) {
1535 offset += PushOctets4((bufferPtr + offset), attributes_.at(i));
1536 HILOGI("attribute: %{public}x", attributes_.at(i));
1537
1538 offset += PushOctets2((bufferPtr + offset), static_cast<uint16_t>(AVRC_MEDIA_CHARACTER_SET_UTF8));
1539
1540 offset += PushOctets2((bufferPtr + offset), values_.at(i).length());
1541 HILOGI("valuelength: %{public}zu", values_.at(i).length());
1542
1543 size_t length = values_.at(i).length();
1544 while (length > 0 && offset < AVRC_TG_GEA_ASSEMBLE_MAX_SIZE + AVRC_TG_GEA_SIZE_OF_ATTRIBUTE_LENGTH +
1545 AVRC_TG_GEA_PARAMETER_LENGTH_SIZE) {
1546 offset += PushOctets1((bufferPtr + offset), values_.at(i).front());
1547 values_.at(i).erase(values_.at(i).begin());
1548 length--;
1549 }
1550 }
1551 HILOGI("values_.size: %{public}zu", values_.size());
1552 if (values_.at(number_ - 1).length() == 0) {
1553 attributes_.erase(attributes_.begin(), attributes_.begin() + number_);
1554 values_.erase(values_.begin(), values_.begin() + number_);
1555 } else {
1556 attributes_.erase(attributes_.begin(), attributes_.begin() + number_ - 1);
1557 values_.erase(values_.begin(), values_.begin() + number_ - 1);
1558 }
1559
1560 packetPos_.pop_front();
1561 PacketPayloadAddLast(pkt, buffer);
1562
1563 BufferFree(buffer);
1564 buffer = nullptr;
1565 bufferPtr = nullptr;
1566
1567 return pkt;
1568 }
1569
DisassembleParameters(uint8_t * buffer)1570 bool AvrcTgGeaPacket::DisassembleParameters(uint8_t *buffer)
1571 {
1572 HILOGI("enter");
1573
1574 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
1575 uint64_t payload = 0x00;
1576 offset += PopOctets2((buffer + offset), payload);
1577 parameterLength_ = static_cast<uint16_t>(payload);
1578 HILOGI("parameterLength_: %{public}d", parameterLength_);
1579
1580 payload = 0x00;
1581 offset += PopOctets8((buffer + offset), payload);
1582 identifier_ = payload;
1583 HILOGI("identifier_: %{public}jx", identifier_);
1584
1585 payload = 0x00;
1586 offset += PopOctets1((buffer + offset), payload);
1587 number_ = static_cast<uint8_t>(payload);
1588 HILOGI("number_: %{public}hhx", number_);
1589
1590 if (number_ != AVRC_TG_GEA_NUMBER_OF_ATTRIBUTES) {
1591 for (int i = 0; i < number_; i++) {
1592 payload = 0x00;
1593 offset += PopOctets4((buffer + offset), payload);
1594 attributes_.push_back(static_cast<uint32_t>(payload));
1595 HILOGI("attributes_: %{public}x", attributes_.at(i));
1596 }
1597 } else {
1598 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_TITLE);
1599 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_ARTIST_NAME);
1600 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_ALBUM_NAME);
1601 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_TRACK_NUMBER);
1602 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_TOTAL_NUMBER_OF_TRACKS);
1603 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_GENRE);
1604 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_PLAYING_TIME);
1605 attributes_.push_back(bluetooth::AVRC_MEDIA_ATTRIBUTE_DEFAULT_COVER_ART);
1606 }
1607
1608 isValid_ = true;
1609
1610 HILOGI("isValid_: %{public}d", isValid_);
1611
1612 return isValid_;
1613 }
1614
GetNumberOfPackets(void)1615 uint16_t AvrcTgGeaPacket::GetNumberOfPackets(void)
1616 {
1617 HILOGI("enter");
1618
1619 uint16_t totalLength = 0x00;
1620 uint8_t totalNumber = 0x00;
1621 int packetNum = 1;
1622 std::pair<uint16_t, uint16_t> tem;
1623 for (int i = 0; i < numOfValues_; i++) {
1624 if (totalLength + AVRC_TG_GEA_ATTRIBUTE_LENGTH < AVRC_TG_GEA_ASSEMBLE_MAX_SIZE) {
1625 totalLength += +AVRC_TG_GEA_ATTRIBUTE_LENGTH;
1626 totalNumber++;
1627 } else {
1628 packetNum++;
1629 i--;
1630 tem = std::make_pair(totalNumber, totalLength);
1631 packetPos_.push_back(tem);
1632 totalLength = 0x00;
1633 totalNumber = 0x00;
1634 continue;
1635 }
1636
1637 if (totalLength + values_.at(i).length() <= AVRC_TG_GEA_ASSEMBLE_MAX_SIZE) {
1638 totalLength += values_.at(i).length();
1639 continue;
1640 }
1641 int length = values_.at(i).length();
1642 do {
1643 if (length > AVRC_TG_GEA_ASSEMBLE_MAX_SIZE - totalLength) {
1644 length -= (AVRC_TG_GEA_ASSEMBLE_MAX_SIZE - totalLength);
1645 packetNum++;
1646 tem = std::make_pair(totalNumber, AVRC_TG_GEA_ASSEMBLE_MAX_SIZE);
1647 packetPos_.push_back(tem);
1648 totalNumber = 1;
1649 totalLength = AVRC_TG_GEA_ATTRIBUTE_LENGTH;
1650 } else {
1651 totalLength += length;
1652 break;
1653 }
1654 } while (length > 0);
1655 }
1656 if (packetNum == 1 || totalNumber != 0) {
1657 tem = std::make_pair(totalNumber, totalLength);
1658 packetPos_.push_back(tem);
1659 }
1660 HILOGI("packetNum: %{public}x", packetNum);
1661 return packetNum;
1662 }
1663
1664 /******************************************************************
1665 * GetPlayStatus *
1666 ******************************************************************/
1667
AvrcTgGpsPacket(uint8_t crCode,uint32_t songLength,uint32_t songPosition,uint8_t playStatus,uint8_t label)1668 AvrcTgGpsPacket::AvrcTgGpsPacket(
1669 uint8_t crCode, uint32_t songLength, uint32_t songPosition, uint8_t playStatus, uint8_t label)
1670 : AvrcTgVendorPacket()
1671 {
1672 HILOGI("crCode:%{public}d, songLength:%{public}u, songPosition:%{public}u, playStatus:%{public}d, "
1673 "label:%{public}d", crCode, songLength, songPosition, playStatus, label);
1674
1675 crCode_ = crCode;
1676 pduId_ = AVRC_TG_PDU_ID_GET_PLAY_STATUS;
1677 parameterLength_ = AVRC_TG_GPS_PARAMETER_LENGTH;
1678 songLength_ = songLength;
1679 songPosition_ = songPosition;
1680 playStatus_ = playStatus;
1681 label_ = label;
1682
1683 AssemblePackets();
1684 }
1685
AvrcTgGpsPacket(Packet * pkt,uint8_t label)1686 AvrcTgGpsPacket::AvrcTgGpsPacket(Packet *pkt, uint8_t label)
1687 : AvrcTgVendorPacket(),
1688 songLength_(AVRC_PLAY_STATUS_INVALID_SONG_LENGTH),
1689 songPosition_(AVRC_PLAY_STATUS_INVALID_SONG_POSITION),
1690 playStatus_(AVRC_PLAY_STATUS_ERROR)
1691 {
1692 HILOGI("label: %{public}d", label);
1693
1694 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1695 pduId_ = AVRC_TG_PDU_ID_GET_PLAY_STATUS;
1696 parameterLength_ = AVRC_TG_GPS_PARAMETER_LENGTH;
1697 label_ = label;
1698
1699 DisassemblePacket(pkt);
1700 }
1701
~AvrcTgGpsPacket(void)1702 AvrcTgGpsPacket::~AvrcTgGpsPacket(void)
1703 {
1704 HILOGI("enter");
1705 }
1706
AssembleParameters(Packet * pkt)1707 Packet *AvrcTgGpsPacket::AssembleParameters(Packet *pkt)
1708 {
1709 HILOGI("enter");
1710
1711 auto buffer = BufferMalloc(
1712 AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_GPS_PARAMETER_LENGTH);
1713 if (buffer == nullptr) {
1714 HILOGE("BufferMalloc fail");
1715 return pkt;
1716 }
1717 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1718 HILOGI("BufferMalloc: %{public}ju",
1719 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_GPS_PARAMETER_LENGTH));
1720
1721 uint16_t offset = 0x0000;
1722 offset += PushOctets1((bufferPtr + offset), packetType_);
1723 HILOGI("packetType_: %{public}hhx", packetType_);
1724
1725 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1726 HILOGI("parameterLength_: %{public}hu", parameterLength_);
1727
1728 offset += PushOctets4((bufferPtr + offset), songLength_);
1729 HILOGI("songLength_: %{public}u", songLength_);
1730
1731 offset += PushOctets4((bufferPtr + offset), songPosition_);
1732 HILOGI("songPosition_: %{public}u", songPosition_);
1733
1734 PushOctets1((bufferPtr + offset), playStatus_);
1735 HILOGI("playStatus_: %{public}hhx", playStatus_);
1736
1737 PacketPayloadAddLast(pkt, buffer);
1738
1739 BufferFree(buffer);
1740 buffer = nullptr;
1741 bufferPtr = nullptr;
1742
1743 return pkt;
1744 }
1745
DisassembleParameters(uint8_t * buffer)1746 bool AvrcTgGpsPacket::DisassembleParameters(uint8_t *buffer)
1747 {
1748 HILOGI("enter");
1749
1750 isValid_ = true;
1751
1752 HILOGI("isValid_: %{public}d", isValid_);
1753
1754 return isValid_;
1755 }
1756
GetNumberOfPackets(void)1757 uint16_t AvrcTgGpsPacket::GetNumberOfPackets(void)
1758 {
1759 HILOGI("enter");
1760
1761 return AVRC_TG_GPS_NUM_OF_PACKETS;
1762 }
1763
1764 /******************************************************************
1765 * RequestContinuingResponse *
1766 ******************************************************************/
1767
AvrcTgRcrPacket()1768 AvrcTgRcrPacket::AvrcTgRcrPacket() : AvrcTgVendorPacket()
1769 {
1770 HILOGI("enter");
1771
1772 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1773 pduId_ = AVRC_TG_PDU_ID_REQUEST_CONTINUING_RESPONSE;
1774 }
1775
AvrcTgRcrPacket(Packet * pkt,uint8_t label)1776 AvrcTgRcrPacket::AvrcTgRcrPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
1777 {
1778 HILOGI("label: %{public}d", label);
1779
1780 crCode_ = AVRC_TG_RSP_CODE_STABLE;
1781 pduId_ = AVRC_TG_PDU_ID_REQUEST_CONTINUING_RESPONSE;
1782 label_ = label;
1783
1784 DisassemblePacket(pkt);
1785 }
1786
~AvrcTgRcrPacket()1787 AvrcTgRcrPacket::~AvrcTgRcrPacket()
1788 {
1789 HILOGI("enter");
1790 }
1791
AssembleParameters(Packet * pkt)1792 Packet *AvrcTgRcrPacket::AssembleParameters(Packet *pkt)
1793 {
1794 HILOGI("enter");
1795
1796 return nullptr;
1797 }
1798
DisassembleParameters(uint8_t * buffer)1799 bool AvrcTgRcrPacket::DisassembleParameters(uint8_t *buffer)
1800 {
1801 HILOGI("enter");
1802
1803 isValid_ = false;
1804
1805 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
1806 uint64_t payload = 0x00;
1807 PopOctets2((buffer + offset), payload);
1808 parameterLength_ = static_cast<uint16_t>(payload);
1809 HILOGI("parameterLength_: %{public}d", parameterLength_);
1810
1811 offset = AVRC_TG_RCR_REQUEST_CONTINUING_PDU_ID_OFFSET;
1812 payload = 0x00;
1813 PopOctets1((buffer + offset), payload);
1814 continuePduId_ = static_cast<uint8_t>(payload);
1815 HILOGI("continuePduId_: %{public}x", continuePduId_);
1816
1817 isValid_ = true;
1818
1819 HILOGI("isValid_: %{public}d", isValid_);
1820
1821 return isValid_;
1822 }
1823
GetNumberOfPackets(void)1824 uint16_t AvrcTgRcrPacket::GetNumberOfPackets(void)
1825 {
1826 HILOGI("enter");
1827
1828 return AVRC_TG_RCR_NUM_OF_PACKETS;
1829 }
1830
1831 /******************************************************************
1832 * AbortContinuingResponse *
1833 ******************************************************************/
1834
AvrcTgAcrPacket()1835 AvrcTgAcrPacket::AvrcTgAcrPacket()
1836 {
1837 HILOGI("enter");
1838 }
1839
AvrcTgAcrPacket(uint8_t pduId,uint8_t label)1840 AvrcTgAcrPacket::AvrcTgAcrPacket(uint8_t pduId, uint8_t label) : AvrcTgVendorPacket()
1841 {
1842 HILOGI("pduId: %{public}d, label: %{public}d", pduId, label);
1843
1844 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
1845 pduId_ = AVRC_TG_PDU_ID_ABORT_CONTINUING_RESPONSE;
1846 parameterLength_ = AVRC_TG_ACR_PARAMETER_LENGTH;
1847 continuePduId_ = pduId;
1848
1849 AssemblePackets();
1850 }
1851
AvrcTgAcrPacket(Packet * pkt,uint8_t label)1852 AvrcTgAcrPacket::AvrcTgAcrPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
1853 {
1854 HILOGI("label: %{public}d", label);
1855
1856 label_ = label;
1857
1858 DisassemblePacket(pkt);
1859 }
1860
~AvrcTgAcrPacket()1861 AvrcTgAcrPacket::~AvrcTgAcrPacket()
1862 {
1863 HILOGI("enter");
1864 }
1865
AssembleParameters(Packet * pkt)1866 Packet *AvrcTgAcrPacket::AssembleParameters(Packet *pkt)
1867 {
1868 HILOGI("enter");
1869
1870 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE);
1871 if (buffer == nullptr) {
1872 HILOGE("BufferMalloc fail");
1873 return pkt;
1874 }
1875 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1876 HILOGI("BufferMalloc: %{public}ju",
1877 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE));
1878
1879 uint16_t offset = 0x0000;
1880 offset += PushOctets1((bufferPtr + offset), packetType_);
1881 HILOGI("packetType_: %{public}hhx", packetType_);
1882
1883 PushOctets2((bufferPtr + offset), parameterLength_);
1884 HILOGI("parameterLength_: %{public}hx", parameterLength_);
1885
1886 PacketPayloadAddLast(pkt, buffer);
1887
1888 BufferFree(buffer);
1889 buffer = nullptr;
1890 bufferPtr = nullptr;
1891
1892 return pkt;
1893 }
1894
DisassembleParameters(uint8_t * buffer)1895 bool AvrcTgAcrPacket::DisassembleParameters(uint8_t *buffer)
1896 {
1897 HILOGI("enter");
1898
1899 isValid_ = false;
1900
1901 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
1902 uint64_t payload = 0x00;
1903 PopOctets2((buffer + offset), payload);
1904 parameterLength_ = static_cast<uint16_t>(payload);
1905 HILOGI("parameterLength_: %{public}d", parameterLength_);
1906
1907 offset = AVRC_TG_ACR_REQUEST_CONTINUING_PDU_ID_OFFSET;
1908 payload = 0x00;
1909 PopOctets1((buffer + offset), payload);
1910 continuePduId_ = static_cast<uint8_t>(payload);
1911 HILOGI("continuePduId_: %{public}x", continuePduId_);
1912
1913 isValid_ = true;
1914
1915 HILOGI("isValid_: %{public}d", isValid_);
1916
1917 return isValid_;
1918 }
1919
GetNumberOfPackets(void)1920 uint16_t AvrcTgAcrPacket::GetNumberOfPackets(void)
1921 {
1922 HILOGI("enter");
1923
1924 return AVRC_TG_ACR_NUM_OF_PACKETS;
1925 }
1926
1927 /******************************************************************
1928 * SetAddressedPlayer *
1929 ******************************************************************/
1930
AvrcTgSapPacket(uint8_t crCode,uint8_t status,uint8_t label)1931 AvrcTgSapPacket::AvrcTgSapPacket(uint8_t crCode, uint8_t status, uint8_t label) : AvrcTgVendorPacket()
1932 {
1933 HILOGI("crCode: %{public}d, status: %{public}d, label: %{public}d", crCode, status, label);
1934
1935 crCode_ = crCode;
1936 pduId_ = AVRC_TG_PDU_ID_SET_ADDRESSED_PLAYER;
1937 parameterLength_ = AVRC_TG_SAP_PARAMETER_LENGTH;
1938 status_ = status;
1939 label_ = label;
1940
1941 AssemblePackets();
1942 }
1943
AvrcTgSapPacket(Packet * pkt,uint8_t label)1944 AvrcTgSapPacket::AvrcTgSapPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket()
1945 {
1946 HILOGI("label: %{public}d", label);
1947
1948 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
1949 pduId_ = AVRC_TG_PDU_ID_SET_ADDRESSED_PLAYER;
1950 parameterLength_ = AVRC_TG_SAP_PARAMETER_LENGTH;
1951 label_ = label;
1952
1953 DisassemblePacket(pkt);
1954 }
1955
~AvrcTgSapPacket()1956 AvrcTgSapPacket::~AvrcTgSapPacket()
1957 {
1958 HILOGI("enter");
1959 }
1960
AssembleParameters(Packet * pkt)1961 Packet *AvrcTgSapPacket::AssembleParameters(Packet *pkt)
1962 {
1963 HILOGI("enter");
1964
1965 size_t bufferSize =
1966 AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_SAP_PARAMETER_LENGTH;
1967 HILOGI("BufferMalloc: %{public}zu", bufferSize);
1968
1969 auto buffer = BufferMalloc(bufferSize);
1970 if (buffer == nullptr) {
1971 HILOGE("BufferMalloc fail");
1972 return pkt;
1973 }
1974 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
1975
1976 uint16_t offset = 0x0000;
1977 offset += PushOctets1((bufferPtr + offset), packetType_);
1978 HILOGI("packetType_: %{public}x", packetType_);
1979
1980 offset += PushOctets2((bufferPtr + offset), parameterLength_);
1981 HILOGI("parameterLength_: %{public}d", parameterLength_);
1982
1983 PushOctets1((bufferPtr + offset), status_);
1984 HILOGI("status_: %{public}x", status_);
1985
1986 PacketPayloadAddLast(pkt, buffer);
1987
1988 BufferFree(buffer);
1989 buffer = nullptr;
1990 bufferPtr = nullptr;
1991
1992 return pkt;
1993 }
1994
DisassembleParameters(uint8_t * buffer)1995 bool AvrcTgSapPacket::DisassembleParameters(uint8_t *buffer)
1996 {
1997 HILOGI("enter");
1998
1999 isValid_ = false;
2000
2001 do {
2002 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
2003 uint64_t payload = 0x00;
2004 offset += PopOctets2((buffer + offset), payload);
2005 parameterLength_ = static_cast<uint16_t>(payload);
2006 HILOGI("parameterLength_: %{public}d", parameterLength_);
2007
2008 payload = 0x00;
2009 PopOctets2((buffer + offset), payload);
2010 playerId_ = static_cast<uint16_t>(payload);
2011 HILOGI("playerId_: %{public}x", playerId_);
2012
2013 isValid_ = true;
2014
2015 HILOGI("isValid_: %{public}d", isValid_);
2016 } while (false);
2017
2018 return isValid_;
2019 }
2020
GetNumberOfPackets(void)2021 uint16_t AvrcTgSapPacket::GetNumberOfPackets(void)
2022 {
2023 HILOGI("enter");
2024
2025 return AVRC_TG_SAP_NUM_OF_PACKETS;
2026 }
2027
2028 /******************************************************************
2029 * PlayItem *
2030 ******************************************************************/
2031
AvrcTgPiPacket(uint8_t crCode,uint8_t status,uint8_t label)2032 AvrcTgPiPacket::AvrcTgPiPacket(uint8_t crCode, uint8_t status, uint8_t label)
2033 : AvrcTgVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
2034 {
2035 HILOGI("crCode: %{public}d, status: %{public}d, label: %{public}d", crCode, status, label);
2036
2037 crCode_ = crCode;
2038 pduId_ = AVRC_TG_PDU_ID_PLAY_ITEM;
2039 parameterLength_ = AVRC_TG_PI_PARAMETER_LENGTH;
2040 label_ = label;
2041 status_ = status;
2042
2043 AssemblePackets();
2044 }
2045
AvrcTgPiPacket(Packet * pkt,uint8_t label)2046 AvrcTgPiPacket::AvrcTgPiPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
2047 {
2048 HILOGI("label: %{public}d", label);
2049
2050 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
2051 pduId_ = AVRC_TG_PDU_ID_PLAY_ITEM;
2052 parameterLength_ = AVRC_TG_PI_PARAMETER_LENGTH;
2053 label_ = label;
2054
2055 DisassemblePacket(pkt);
2056 }
2057
~AvrcTgPiPacket(void)2058 AvrcTgPiPacket::~AvrcTgPiPacket(void)
2059 {
2060 HILOGI("enter");
2061 }
2062
AssembleParameters(Packet * pkt)2063 Packet *AvrcTgPiPacket::AssembleParameters(Packet *pkt)
2064 {
2065 HILOGI("enter");
2066
2067 size_t bufferSize =
2068 AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_PI_PARAMETER_LENGTH;
2069 HILOGI("BufferMalloc: %{public}zu", bufferSize);
2070
2071 auto buffer = BufferMalloc(bufferSize);
2072 if (buffer == nullptr) {
2073 HILOGE("BufferMalloc fail");
2074 return pkt;
2075 }
2076 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
2077
2078 uint16_t offset = 0x0000;
2079 offset += PushOctets1((bufferPtr + offset), packetType_);
2080 HILOGI("packetType_: %{public}x", packetType_);
2081
2082 offset += PushOctets2((bufferPtr + offset), parameterLength_);
2083 HILOGI("parameterLength_: %{public}d", parameterLength_);
2084
2085 PushOctets1((bufferPtr + offset), status_);
2086 HILOGI("status_: %{public}x", status_);
2087
2088 PacketPayloadAddLast(pkt, buffer);
2089
2090 BufferFree(buffer);
2091 buffer = nullptr;
2092 bufferPtr = nullptr;
2093
2094 return pkt;
2095 }
2096
DisassembleParameters(uint8_t * buffer)2097 bool AvrcTgPiPacket::DisassembleParameters(uint8_t *buffer)
2098 {
2099 HILOGI("enter");
2100
2101 isValid_ = false;
2102
2103 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
2104 uint64_t payload = 0x00;
2105 offset += PopOctets2((buffer + offset), payload);
2106 parameterLength_ = static_cast<uint16_t>(payload);
2107 HILOGI("parameterLength_: %{public}d", parameterLength_);
2108
2109 payload = 0x00;
2110 offset += PopOctets1((buffer + offset), payload);
2111 scope_ = static_cast<uint8_t>(payload);
2112 HILOGI("scope_: %{public}x", scope_);
2113
2114 payload = 0x00;
2115 offset += PopOctets8((buffer + offset), payload);
2116 uid_ = payload;
2117 HILOGI("uid_: %{public}jx", uid_);
2118
2119 payload = 0x00;
2120 PopOctets2((buffer + offset), payload);
2121 uidCounter_ = static_cast<uint16_t>(payload);
2122 HILOGI("uidCounter_: %{public}d", uidCounter_);
2123
2124 isValid_ = true;
2125
2126 return isValid_;
2127 }
2128
GetNumberOfPackets(void)2129 uint16_t AvrcTgPiPacket::GetNumberOfPackets(void)
2130 {
2131 HILOGI("enter");
2132
2133 return AVRC_TG_PI_NUM_OF_PACKETS;
2134 }
2135
2136 /******************************************************************
2137 * AddToNowPlaying *
2138 ******************************************************************/
2139
AvrcTgAtnpPacket(uint8_t crCode,uint8_t status,uint8_t label)2140 AvrcTgAtnpPacket::AvrcTgAtnpPacket(uint8_t crCode, uint8_t status, uint8_t label)
2141 : AvrcTgVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
2142 {
2143 HILOGI("crCode: %{public}d, status: %{public}d, label: %{public}d", crCode, status, label);
2144
2145 crCode_ = crCode;
2146 pduId_ = AVRC_TG_PDU_ID_ADD_TO_NOW_PLAYING;
2147 parameterLength_ = AVRC_TG_ATNP_PARAMETER_LENGTH;
2148 status_ = status;
2149 label_ = label;
2150
2151 AssemblePackets();
2152 }
2153
AvrcTgAtnpPacket(Packet * pkt,uint8_t label)2154 AvrcTgAtnpPacket::AvrcTgAtnpPacket(Packet *pkt, uint8_t label) : AvrcTgVendorPacket(), scope_(AVRC_MEDIA_SCOPE_INVALID)
2155 {
2156 HILOGI("label: %{public}d", label);
2157
2158 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
2159 pduId_ = AVRC_TG_PDU_ID_ADD_TO_NOW_PLAYING;
2160 parameterLength_ = AVRC_TG_ATNP_PARAMETER_LENGTH;
2161 label_ = label;
2162
2163 DisassemblePacket(pkt);
2164 }
2165
~AvrcTgAtnpPacket()2166 AvrcTgAtnpPacket::~AvrcTgAtnpPacket()
2167 {
2168 HILOGI("enter");
2169 }
2170
AssembleParameters(Packet * pkt)2171 Packet *AvrcTgAtnpPacket::AssembleParameters(Packet *pkt)
2172 {
2173 HILOGI("enter");
2174
2175 size_t bufferSize =
2176 AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_ATNP_PARAMETER_LENGTH;
2177 HILOGI("BufferMalloc: %{public}zu", bufferSize);
2178
2179 auto buffer = BufferMalloc(bufferSize);
2180 if (buffer == nullptr) {
2181 HILOGE("BufferMalloc fail");
2182 return pkt;
2183 }
2184 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
2185
2186 uint16_t offset = 0x0000;
2187 offset += PushOctets1((bufferPtr + offset), packetType_);
2188 HILOGI("packetType_: %{public}x", packetType_);
2189
2190 offset += PushOctets2((bufferPtr + offset), parameterLength_);
2191 HILOGI("parameterLength_: %{public}d", parameterLength_);
2192
2193 PushOctets1((bufferPtr + offset), status_);
2194 HILOGI("status_: %{public}x", status_);
2195
2196 PacketPayloadAddLast(pkt, buffer);
2197
2198 BufferFree(buffer);
2199 buffer = nullptr;
2200 bufferPtr = nullptr;
2201
2202 return pkt;
2203 }
2204
DisassembleParameters(uint8_t * buffer)2205 bool AvrcTgAtnpPacket::DisassembleParameters(uint8_t *buffer)
2206 {
2207 HILOGI("enter");
2208
2209 isValid_ = false;
2210
2211 do {
2212 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
2213 uint64_t payload = 0x00;
2214 offset += PopOctets2((buffer + offset), payload);
2215 parameterLength_ = static_cast<uint16_t>(payload);
2216 HILOGI("parameterLength_: %{public}d", parameterLength_);
2217
2218 payload = 0x00;
2219 offset += PopOctets1((buffer + offset), payload);
2220 scope_ = static_cast<uint8_t>(payload);
2221 HILOGI("scope_: %{public}x", scope_);
2222 if (scope_ < AVRC_MEDIA_SCOPE_PLAYER_LIST || scope_ > AVRC_MEDIA_SCOPE_NOW_PLAYING) {
2223 status_ = AVRC_ES_CODE_INVALID_SCOPE;
2224 break;
2225 }
2226
2227 payload = 0x00;
2228 offset += PopOctets8((buffer + offset), payload);
2229 uid_ = static_cast<uint64_t>(payload);
2230 HILOGI("uid_: %{public}jx", uid_);
2231
2232 payload = 0x00;
2233 PopOctets2((buffer + offset), payload);
2234 uidCounter_ = static_cast<uint16_t>(payload);
2235 HILOGI("uidCounter_: %{public}d", uidCounter_);
2236
2237 isValid_ = true;
2238
2239 HILOGI("isValid_: %{public}d", isValid_);
2240 } while (false);
2241
2242 return isValid_;
2243 }
2244
GetNumberOfPackets(void)2245 uint16_t AvrcTgAtnpPacket::GetNumberOfPackets(void)
2246 {
2247 HILOGI("enter");
2248
2249 return AVRC_TG_ATNP_NUM_OF_PACKETS;
2250 }
2251
2252 /******************************************************************
2253 * SetAbsoluteVolume *
2254 ******************************************************************/
2255
AvrcTgSavPacket(uint8_t crCode,uint8_t volume,uint8_t label)2256 AvrcTgSavPacket::AvrcTgSavPacket(uint8_t crCode, uint8_t volume, uint8_t label)
2257 : AvrcTgVendorPacket(), volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
2258 {
2259 HILOGI("crCode: %{public}d, volume: %{public}d, label: %{public}d", crCode, volume, label);
2260
2261 crCode_ = crCode;
2262 pduId_ = AVRC_TG_PDU_ID_SET_ABSOLUTE_VOLUME;
2263 parameterLength_ = AVRC_TG_SAV_VOLUME_SIZE;
2264 label_ = label;
2265 volume_ = volume;
2266
2267 AssemblePackets();
2268 }
2269
AvrcTgSavPacket(Packet * pkt,uint8_t label)2270 AvrcTgSavPacket::AvrcTgSavPacket(Packet *pkt, uint8_t label)
2271 : AvrcTgVendorPacket(), volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
2272 {
2273 HILOGI("label: %{public}d", label);
2274
2275 crCode_ = AVRC_TG_RSP_CODE_ACCEPTED;
2276 pduId_ = AVRC_TG_PDU_ID_SET_ABSOLUTE_VOLUME;
2277 parameterLength_ = AVRC_TG_SAV_VOLUME_SIZE;
2278 label_ = label;
2279
2280 DisassemblePacket(pkt);
2281 }
2282
~AvrcTgSavPacket()2283 AvrcTgSavPacket::~AvrcTgSavPacket()
2284 {
2285 HILOGI("enter");
2286 }
2287
AssembleParameters(Packet * pkt)2288 Packet *AvrcTgSavPacket::AssembleParameters(Packet *pkt)
2289 {
2290 HILOGI("enter");
2291
2292 size_t bufferSize =
2293 AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_SAV_VOLUME_SIZE;
2294 HILOGI("BufferMalloc: %{public}zu", bufferSize);
2295
2296 auto buffer = BufferMalloc(bufferSize);
2297 if (buffer == nullptr) {
2298 HILOGE("BufferMalloc fail");
2299 return pkt;
2300 }
2301 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
2302
2303 uint16_t offset = 0x0000;
2304 offset += PushOctets1((bufferPtr + offset), packetType_);
2305 HILOGI("packetType_: %{public}x", packetType_);
2306
2307 offset += PushOctets2((bufferPtr + offset), parameterLength_);
2308 HILOGI("parameterLength_: %{public}d", parameterLength_);
2309
2310 PushOctets1((bufferPtr + offset), volume_ & 0b01111111);
2311 HILOGI("volume_: %{public}x", volume_);
2312
2313 PacketPayloadAddLast(pkt, buffer);
2314
2315 BufferFree(buffer);
2316 buffer = nullptr;
2317 bufferPtr = nullptr;
2318
2319 return pkt;
2320 }
2321
DisassembleParameters(uint8_t * buffer)2322 bool AvrcTgSavPacket::DisassembleParameters(uint8_t *buffer)
2323 {
2324 HILOGI("enter");
2325
2326 isValid_ = false;
2327
2328 do {
2329 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
2330 uint64_t payload = 0x00;
2331 offset += PopOctets2((buffer + offset), payload);
2332 parameterLength_ = static_cast<uint16_t>(payload);
2333 HILOGI("parameterLength_: %{public}d", parameterLength_);
2334
2335 payload = 0x00;
2336 PopOctets1((buffer + offset), payload);
2337 volume_ = static_cast<uint8_t>(payload) & 0b01111111;
2338 HILOGI("volume_: %{public}x", volume_);
2339
2340 if (parameterLength_ == AVRC_TG_VENDOR_PARAMETER_LENGTH || volume_ < AVRC_ABSOLUTE_VOLUME_PERCENTAGE_0 ||
2341 volume_ > AVRC_ABSOLUTE_VOLUME_PERCENTAGE_100) {
2342 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
2343 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
2344 AssembleRejectPacket();
2345 break;
2346 }
2347
2348 isValid_ = true;
2349
2350 HILOGI("isValid_: %{public}d", isValid_);
2351 } while (false);
2352
2353 return isValid_;
2354 }
2355
GetNumberOfPackets(void)2356 uint16_t AvrcTgSavPacket::GetNumberOfPackets(void)
2357 {
2358 HILOGI("enter");
2359
2360 return AVRC_TG_SAV_NUM_OF_PACKETS;
2361 }
2362 } // namespace bluetooth
2363 } // namespace OHOS
2364