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 "audio_service_log.h"
17 #include "audio_system_manager.h"
18
19 namespace OHOS {
20 namespace AudioStandard {
21 /**
22 * @brief The AudioDeviceDescriptor provides
23 * different sets of audio devices and their roles
24 */
AudioDeviceDescriptor(DeviceType type,DeviceRole role,int32_t interruptGroupId,int32_t volumeGroupId,std::string networkId)25 AudioDeviceDescriptor::AudioDeviceDescriptor(DeviceType type, DeviceRole role, int32_t interruptGroupId,
26 int32_t volumeGroupId, std::string networkId)
27 : deviceType_(type), deviceRole_(role), interruptGroupId_(interruptGroupId), volumeGroupId_(volumeGroupId),
28 networkId_(networkId)
29 {
30 deviceId_ = 0;
31 audioStreamInfo_ = {};
32 channelMasks_ = 0;
33 channelIndexMasks_ = 0;
34 deviceName_ = "";
35 macAddress_ = "";
36 displayName_ = "";
37 deviceCategory_ = CATEGORY_DEFAULT;
38 connectTimeStamp_ = 0;
39 connectState_ = CONNECTED;
40 pairDeviceDescriptor_ = nullptr;
41 isScoRealConnected_ = false;
42 isEnable_ = true;
43 exceptionFlag_ = false;
44 }
45
AudioDeviceDescriptor(DeviceType type,DeviceRole role)46 AudioDeviceDescriptor::AudioDeviceDescriptor(DeviceType type, DeviceRole role) : deviceType_(type), deviceRole_(role)
47 {
48 deviceId_ = 0;
49 audioStreamInfo_ = {};
50 channelMasks_ = 0;
51 channelIndexMasks_ = 0;
52 deviceName_ = "";
53 macAddress_ = "";
54
55 volumeGroupId_ = 0;
56 interruptGroupId_ = 0;
57 networkId_ = LOCAL_NETWORK_ID;
58 displayName_ = "";
59 deviceCategory_ = CATEGORY_DEFAULT;
60 connectTimeStamp_ = 0;
61 connectState_ = CONNECTED;
62 pairDeviceDescriptor_ = nullptr;
63 isScoRealConnected_ = false;
64 isEnable_ = true;
65 exceptionFlag_ = false;
66 }
67
AudioDeviceDescriptor()68 AudioDeviceDescriptor::AudioDeviceDescriptor()
69 : AudioDeviceDescriptor(DeviceType::DEVICE_TYPE_NONE, DeviceRole::DEVICE_ROLE_NONE)
70 {}
71
AudioDeviceDescriptor(const AudioDeviceDescriptor & deviceDescriptor)72 AudioDeviceDescriptor::AudioDeviceDescriptor(const AudioDeviceDescriptor &deviceDescriptor)
73 {
74 deviceId_ = deviceDescriptor.deviceId_;
75 deviceName_ = deviceDescriptor.deviceName_;
76 macAddress_ = deviceDescriptor.macAddress_;
77 deviceType_ = deviceDescriptor.deviceType_;
78 deviceRole_ = deviceDescriptor.deviceRole_;
79 audioStreamInfo_.channels = deviceDescriptor.audioStreamInfo_.channels;
80 audioStreamInfo_.encoding = deviceDescriptor.audioStreamInfo_.encoding;
81 audioStreamInfo_.format = deviceDescriptor.audioStreamInfo_.format;
82 audioStreamInfo_.samplingRate = deviceDescriptor.audioStreamInfo_.samplingRate;
83 channelMasks_ = deviceDescriptor.channelMasks_;
84 channelIndexMasks_ = deviceDescriptor.channelIndexMasks_;
85 volumeGroupId_ = deviceDescriptor.volumeGroupId_;
86 interruptGroupId_ = deviceDescriptor.interruptGroupId_;
87 networkId_ = deviceDescriptor.networkId_;
88 displayName_ = deviceDescriptor.displayName_;
89 deviceCategory_ = deviceDescriptor.deviceCategory_;
90 connectTimeStamp_ = deviceDescriptor.connectTimeStamp_;
91 connectState_ = deviceDescriptor.connectState_;
92 pairDeviceDescriptor_ = deviceDescriptor.pairDeviceDescriptor_;
93 isScoRealConnected_ = deviceDescriptor.isScoRealConnected_;
94 isEnable_ = deviceDescriptor.isEnable_;
95 exceptionFlag_ = deviceDescriptor.exceptionFlag_;
96 }
97
AudioDeviceDescriptor(const sptr<AudioDeviceDescriptor> & deviceDescriptor)98 AudioDeviceDescriptor::AudioDeviceDescriptor(const sptr<AudioDeviceDescriptor> &deviceDescriptor)
99 {
100 CHECK_AND_RETURN_LOG(deviceDescriptor != nullptr, "Error input parameter");
101 deviceId_ = deviceDescriptor->deviceId_;
102 deviceName_ = deviceDescriptor->deviceName_;
103 macAddress_ = deviceDescriptor->macAddress_;
104 deviceType_ = deviceDescriptor->deviceType_;
105 deviceRole_ = deviceDescriptor->deviceRole_;
106 audioStreamInfo_.channels = deviceDescriptor->audioStreamInfo_.channels;
107 audioStreamInfo_.encoding = deviceDescriptor->audioStreamInfo_.encoding;
108 audioStreamInfo_.format = deviceDescriptor->audioStreamInfo_.format;
109 audioStreamInfo_.samplingRate = deviceDescriptor->audioStreamInfo_.samplingRate;
110 channelMasks_ = deviceDescriptor->channelMasks_;
111 channelIndexMasks_ = deviceDescriptor->channelIndexMasks_;
112 volumeGroupId_ = deviceDescriptor->volumeGroupId_;
113 interruptGroupId_ = deviceDescriptor->interruptGroupId_;
114 networkId_ = deviceDescriptor->networkId_;
115 displayName_ = deviceDescriptor->displayName_;
116 deviceCategory_ = deviceDescriptor->deviceCategory_;
117 connectTimeStamp_ = deviceDescriptor->connectTimeStamp_;
118 connectState_ = deviceDescriptor->connectState_;
119 pairDeviceDescriptor_ = deviceDescriptor->pairDeviceDescriptor_;
120 isScoRealConnected_ = deviceDescriptor->isScoRealConnected_;
121 isEnable_ = deviceDescriptor->isEnable_;
122 exceptionFlag_ = deviceDescriptor->exceptionFlag_;
123 }
124
~AudioDeviceDescriptor()125 AudioDeviceDescriptor::~AudioDeviceDescriptor()
126 {
127 pairDeviceDescriptor_ = nullptr;
128 }
129
getType()130 DeviceType AudioDeviceDescriptor::getType()
131 {
132 return deviceType_;
133 }
134
getRole() const135 DeviceRole AudioDeviceDescriptor::getRole() const
136 {
137 return deviceRole_;
138 }
139
Marshalling(Parcel & parcel) const140 bool AudioDeviceDescriptor::Marshalling(Parcel &parcel) const
141 {
142 parcel.WriteInt32(deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET ? DEVICE_TYPE_USB_HEADSET : deviceType_);
143 parcel.WriteInt32(deviceRole_);
144 parcel.WriteInt32(deviceId_);
145
146 audioStreamInfo_.Marshalling(parcel);
147
148 parcel.WriteInt32(channelMasks_);
149 parcel.WriteInt32(channelIndexMasks_);
150
151 parcel.WriteString(deviceName_);
152 parcel.WriteString(macAddress_);
153
154 parcel.WriteInt32(interruptGroupId_);
155 parcel.WriteInt32(volumeGroupId_);
156 parcel.WriteString(networkId_);
157 parcel.WriteString(displayName_);
158
159 parcel.WriteInt32(deviceCategory_);
160 return true;
161 }
162
Unmarshalling(Parcel & in)163 sptr<AudioDeviceDescriptor> AudioDeviceDescriptor::Unmarshalling(Parcel &in)
164 {
165 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = new(std::nothrow) AudioDeviceDescriptor();
166 if (audioDeviceDescriptor == nullptr) {
167 return nullptr;
168 }
169
170 audioDeviceDescriptor->deviceType_ = static_cast<DeviceType>(in.ReadInt32());
171 audioDeviceDescriptor->deviceRole_ = static_cast<DeviceRole>(in.ReadInt32());
172 audioDeviceDescriptor->deviceId_ = in.ReadInt32();
173
174 audioDeviceDescriptor->audioStreamInfo_.Unmarshalling(in);
175
176 audioDeviceDescriptor->channelMasks_ = in.ReadInt32();
177 audioDeviceDescriptor->channelIndexMasks_ = in.ReadInt32();
178
179 audioDeviceDescriptor->deviceName_ = in.ReadString();
180 audioDeviceDescriptor->macAddress_ = in.ReadString();
181
182 audioDeviceDescriptor->interruptGroupId_ = in.ReadInt32();
183 audioDeviceDescriptor->volumeGroupId_ = in.ReadInt32();
184 audioDeviceDescriptor->networkId_ = in.ReadString();
185 audioDeviceDescriptor->displayName_ = in.ReadString();
186
187 audioDeviceDescriptor->deviceCategory_ = static_cast<DeviceCategory>(in.ReadInt32());
188
189 return audioDeviceDescriptor;
190 }
191
SetDeviceInfo(std::string deviceName,std::string macAddress)192 void AudioDeviceDescriptor::SetDeviceInfo(std::string deviceName, std::string macAddress)
193 {
194 deviceName_ = deviceName;
195 macAddress_ = macAddress;
196 }
197
SetDeviceCapability(const DeviceStreamInfo & audioStreamInfo,int32_t channelMask,int32_t channelIndexMasks)198 void AudioDeviceDescriptor::SetDeviceCapability(const DeviceStreamInfo &audioStreamInfo, int32_t channelMask,
199 int32_t channelIndexMasks)
200 {
201 audioStreamInfo_.channels = audioStreamInfo.channels;
202 audioStreamInfo_.encoding = audioStreamInfo.encoding;
203 audioStreamInfo_.format = audioStreamInfo.format;
204 audioStreamInfo_.samplingRate = audioStreamInfo.samplingRate;
205 channelMasks_ = channelMask;
206 channelIndexMasks_ = channelIndexMasks;
207 }
208
isSameDevice(const DeviceInfo & deviceInfo)209 bool AudioDeviceDescriptor::isSameDevice(const DeviceInfo &deviceInfo)
210 {
211 return deviceInfo.deviceType == deviceType_ &&
212 deviceInfo.macAddress == macAddress_ &&
213 deviceInfo.networkId == networkId_;
214 }
215
isSameDeviceDesc(const std::unique_ptr<AudioDeviceDescriptor> & deviceDescriptor)216 bool AudioDeviceDescriptor::isSameDeviceDesc(const std::unique_ptr<AudioDeviceDescriptor> &deviceDescriptor)
217 {
218 CHECK_AND_RETURN_RET_LOG(deviceDescriptor != nullptr, false, "Invalid device descriptor");
219 return deviceDescriptor->deviceType_ == deviceType_ &&
220 deviceDescriptor->macAddress_ == macAddress_ &&
221 deviceDescriptor->networkId_ == networkId_;
222 }
223
AudioRendererFilter()224 AudioRendererFilter::AudioRendererFilter()
225 {}
226
~AudioRendererFilter()227 AudioRendererFilter::~AudioRendererFilter()
228 {}
229
Marshalling(Parcel & parcel) const230 bool AudioRendererFilter::Marshalling(Parcel &parcel) const
231 {
232 return parcel.WriteInt32(uid)
233 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType))
234 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage))
235 && parcel.WriteInt32(static_cast<int32_t>(streamType))
236 && parcel.WriteInt32(rendererInfo.rendererFlags)
237 && parcel.WriteInt32(streamId);
238 }
239
Unmarshalling(Parcel & in)240 sptr<AudioRendererFilter> AudioRendererFilter::Unmarshalling(Parcel &in)
241 {
242 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
243 if (audioRendererFilter == nullptr) {
244 return nullptr;
245 }
246
247 audioRendererFilter->uid = in.ReadInt32();
248 audioRendererFilter->rendererInfo.contentType = static_cast<ContentType>(in.ReadInt32());
249 audioRendererFilter->rendererInfo.streamUsage = static_cast<StreamUsage>(in.ReadInt32());
250 audioRendererFilter->streamType = static_cast<AudioStreamType>(in.ReadInt32());
251 audioRendererFilter->rendererInfo.rendererFlags = in.ReadInt32();
252 audioRendererFilter->streamId = in.ReadInt32();
253
254 return audioRendererFilter;
255 }
256
AudioCapturerFilter()257 AudioCapturerFilter::AudioCapturerFilter()
258 {}
259
~AudioCapturerFilter()260 AudioCapturerFilter::~AudioCapturerFilter()
261 {}
262
Marshalling(Parcel & parcel) const263 bool AudioCapturerFilter::Marshalling(Parcel &parcel) const
264 {
265 return parcel.WriteInt32(uid)
266 && parcel.WriteInt32(static_cast<int32_t>(capturerInfo.sourceType))
267 && parcel.WriteInt32(capturerInfo.capturerFlags);
268 }
269
Unmarshalling(Parcel & in)270 sptr<AudioCapturerFilter> AudioCapturerFilter::Unmarshalling(Parcel &in)
271 {
272 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
273 CHECK_AND_RETURN_RET(audioCapturerFilter != nullptr, nullptr);
274
275 audioCapturerFilter->uid = in.ReadInt32();
276 audioCapturerFilter->capturerInfo.sourceType = static_cast<SourceType>(in.ReadInt32());
277 audioCapturerFilter->capturerInfo.capturerFlags = in.ReadInt32();
278
279 return audioCapturerFilter;
280 }
281 } // namespace AudioStandard
282 } // namespace OHOS
283