1 /*
2 * Copyright (C) 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 "bluetooth_a2dp_a2dpCodecStatus.h"
17 #include <vector>
18 #include "bluetooth_log.h"
19
20 namespace OHOS {
21 namespace Bluetooth {
Marshalling(Parcel & parcel) const22 bool BluetoothA2dpCodecStatus::Marshalling(Parcel &parcel) const
23 {
24 bool status = true;
25
26 status = parcel.WriteInt32((int)codecInfo.codecPriority);
27 if (!status) {
28 return status;
29 }
30
31 status = parcel.WriteInt32((int)codecInfo.codecType);
32 if (!status) {
33 return status;
34 }
35
36 status = parcel.WriteInt32((int)codecInfo.sampleRate);
37 if (!status) {
38 return status;
39 }
40
41 status = parcel.WriteInt32((int)codecInfo.bitsPerSample);
42 if (!status) {
43 return status;
44 }
45
46 status = parcel.WriteInt32((int)codecInfo.channelMode);
47 if (!status) {
48 return status;
49 }
50
51 status = parcel.WriteInt64(codecInfo.codecSpecific1);
52 if (!status) {
53 return status;
54 }
55
56 status = parcel.WriteInt64(codecInfo.codecSpecific2);
57 if (!status) {
58 return status;
59 }
60
61 status = parcel.WriteInt64(codecInfo.codecSpecific3);
62 if (!status) {
63 return status;
64 }
65
66 status = parcel.WriteInt64(codecInfo.codecSpecific4);
67 if (!status) {
68 return status;
69 }
70
71 std::vector<BluetoothA2dpCodecInfo> localCodecInfo;
72 BluetoothA2dpCodecInfo codecInfo {};
73 for (auto& iter : codecInfoLocalCap) {
74 codecInfo.codecPriority = iter.codecPriority;
75 codecInfo.codecType = iter.codecType;
76 codecInfo.sampleRate = iter.sampleRate;
77 codecInfo.bitsPerSample = iter.bitsPerSample;
78 codecInfo.channelMode = iter.channelMode;
79 codecInfo.codecSpecific1 = iter.codecSpecific1;
80 codecInfo.codecSpecific2 = iter.codecSpecific2;
81 codecInfo.codecSpecific3 = iter.codecSpecific3;
82 codecInfo.codecSpecific4 = iter.codecSpecific4;
83 localCodecInfo.push_back(codecInfo);
84 }
85 status = WriteParcelableCodecVector(localCodecInfo, parcel);
86 if (!status) {
87 return status;
88 }
89
90 std::vector<BluetoothA2dpCodecInfo> confirmCodecInfo;
91 for (auto& iter : codecInfoConfirmCap) {
92 codecInfo.codecPriority = iter.codecPriority;
93 codecInfo.codecType = iter.codecType;
94 codecInfo.sampleRate = iter.sampleRate;
95 codecInfo.bitsPerSample = iter.bitsPerSample;
96 codecInfo.channelMode = iter.channelMode;
97 codecInfo.codecSpecific1 = iter.codecSpecific1;
98 codecInfo.codecSpecific2 = iter.codecSpecific2;
99 codecInfo.codecSpecific3 = iter.codecSpecific3;
100 codecInfo.codecSpecific4 = iter.codecSpecific4;
101 confirmCodecInfo.push_back(codecInfo);
102 }
103 status = WriteParcelableCodecVector(confirmCodecInfo, parcel);
104 if (!status) {
105 return status;
106 }
107
108 return status;
109 }
110
WriteParcelableCodecVector(const std::vector<BluetoothA2dpCodecInfo> & localCodecInfo,Parcel & parcel) const111 bool BluetoothA2dpCodecStatus::WriteParcelableCodecVector(
112 const std::vector<BluetoothA2dpCodecInfo> &localCodecInfo, Parcel &parcel) const
113 {
114 if (!parcel.WriteInt32(localCodecInfo.size())) {
115 HILOGE("write WriteParcelableVector failed");
116 return false;
117 }
118
119 for (auto codeInfo : localCodecInfo) {
120 if (!parcel.WriteParcelable(&codeInfo)) {
121 HILOGE("write WriteParcelableVector failed");
122 return false;
123 }
124 }
125 return true;
126 }
127
WriteToParcel(Parcel & parcel)128 bool BluetoothA2dpCodecStatus::WriteToParcel(Parcel &parcel)
129 {
130 return Marshalling(parcel);
131 }
132
Unmarshalling(Parcel & parcel)133 BluetoothA2dpCodecStatus *BluetoothA2dpCodecStatus::Unmarshalling(Parcel &parcel)
134 {
135 BluetoothA2dpCodecStatus *codecData = new BluetoothA2dpCodecStatus();
136 if (codecData != nullptr && !codecData->ReadFromParcel(parcel)) {
137 delete codecData;
138 codecData = nullptr;
139 }
140
141 return codecData;
142 }
143
ReadFromParcel(Parcel & parcel)144 bool BluetoothA2dpCodecStatus::ReadFromParcel(Parcel &parcel)
145 {
146 bool status = true;
147 int tempInt;
148 int64_t tempInt16;
149
150 status = parcel.ReadInt32(tempInt);
151 if (!status) {
152 return status;
153 }
154 codecInfo.codecPriority = (uint8_t)tempInt;
155
156 status = parcel.ReadInt32(tempInt);
157 if (!status) {
158 return status;
159 }
160 codecInfo.codecType = (uint8_t)tempInt;
161
162 status = parcel.ReadInt32(tempInt);
163 if (!status) {
164 return status;
165 }
166 codecInfo.sampleRate = (uint32_t)tempInt;
167
168 status = parcel.ReadInt32(tempInt);
169 if (!status) {
170 return status;
171 }
172 codecInfo.bitsPerSample = (uint8_t)tempInt;
173
174 status = parcel.ReadInt32(tempInt);
175 if (!status) {
176 return status;
177 }
178 codecInfo.channelMode = (uint8_t)tempInt;
179
180 status = parcel.ReadInt64(tempInt16);
181 if (!status) {
182 return status;
183 }
184 codecInfo.codecSpecific1 = (uint64_t)tempInt16;
185
186 status = parcel.ReadInt64(tempInt16);
187 if (!status) {
188 return status;
189 }
190 codecInfo.codecSpecific2 = (uint64_t)tempInt16;
191
192 status = parcel.ReadInt64(tempInt16);
193 if (!status) {
194 return status;
195 }
196 codecInfo.codecSpecific3 = (uint64_t)tempInt16;
197
198 status = parcel.ReadInt64(tempInt16);
199 if (!status) {
200 return status;
201 }
202 codecInfo.codecSpecific4 = (uint64_t)tempInt16;
203
204 std::vector<BluetoothA2dpCodecInfo> localCodecInfo;
205 status = ReadParcelableVector(localCodecInfo, parcel);
206 if (!status) {
207 return status;
208 }
209 BluetoothA2dpCodecInfo codecInfo {};
210 for (auto& iter : localCodecInfo) {
211 codecInfo.codecPriority = iter.codecPriority;
212 codecInfo.codecType = iter.codecType;
213 codecInfo.sampleRate = iter.sampleRate;
214 codecInfo.bitsPerSample = iter.bitsPerSample;
215 codecInfo.channelMode = iter.channelMode;
216 codecInfo.codecSpecific1 = iter.codecSpecific1;
217 codecInfo.codecSpecific2 = iter.codecSpecific2;
218 codecInfo.codecSpecific3 = iter.codecSpecific3;
219 codecInfo.codecSpecific4 = iter.codecSpecific4;
220 codecInfoLocalCap.push_back(codecInfo);
221 }
222
223 std::vector<BluetoothA2dpCodecInfo> confirmCodecInfo;
224 status = ReadParcelableVector(confirmCodecInfo, parcel);
225 if (!status) {
226 return status;
227 }
228 for (auto& iter : confirmCodecInfo) {
229 codecInfo.codecPriority = iter.codecPriority;
230 codecInfo.codecType = iter.codecType;
231 codecInfo.sampleRate = iter.sampleRate;
232 codecInfo.bitsPerSample = iter.bitsPerSample;
233 codecInfo.channelMode = iter.channelMode;
234 codecInfo.codecSpecific1 = iter.codecSpecific1;
235 codecInfo.codecSpecific2 = iter.codecSpecific2;
236 codecInfo.codecSpecific3 = iter.codecSpecific3;
237 codecInfo.codecSpecific4 = iter.codecSpecific4;
238 codecInfoConfirmCap.push_back(codecInfo);
239 }
240 return true;
241 }
242
ReadParcelableVector(const std::vector<BluetoothA2dpCodecInfo> & localCodecInfo,Parcel & parcel) const243 bool BluetoothA2dpCodecStatus::ReadParcelableVector(
244 const std::vector<BluetoothA2dpCodecInfo> &localCodecInfo, Parcel &parcel) const
245 {
246 int size = localCodecInfo.size();
247 if (!parcel.ReadInt32(size)) {
248 HILOGE("read ReadParcelableVector failed");
249 return false;
250 }
251
252 for (auto codeInfo : localCodecInfo) {
253 if (&codeInfo != parcel.ReadParcelable<BluetoothA2dpCodecInfo>()) {
254 HILOGE("read ReadParcelableVector failed");
255 return false;
256 }
257 }
258 return true;
259 }
260
261 } // namespace Bluetooth
262 } // namespace OHOS