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_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 deviceName_ = "";
34 macAddress_ = "";
35 }
36
AudioDeviceDescriptor(DeviceType type,DeviceRole role)37 AudioDeviceDescriptor::AudioDeviceDescriptor(DeviceType type, DeviceRole role) : deviceType_(type), deviceRole_(role)
38 {
39 deviceId_ = 0;
40 audioStreamInfo_ = {};
41 channelMasks_ = 0;
42 deviceName_ = "";
43 macAddress_ = "";
44
45 volumeGroupId_ = 0;
46 interruptGroupId_ = 0;
47 networkId_ = LOCAL_NETWORK_ID;
48 }
49
AudioDeviceDescriptor()50 AudioDeviceDescriptor::AudioDeviceDescriptor()
51 : AudioDeviceDescriptor(DeviceType::DEVICE_TYPE_NONE, DeviceRole::DEVICE_ROLE_NONE)
52 {}
53
AudioDeviceDescriptor(const AudioDeviceDescriptor & deviceDescriptor)54 AudioDeviceDescriptor::AudioDeviceDescriptor(const AudioDeviceDescriptor &deviceDescriptor)
55 {
56 deviceId_ = deviceDescriptor.deviceId_;
57 deviceName_ = deviceDescriptor.deviceName_;
58 macAddress_ = deviceDescriptor.macAddress_;
59 deviceType_ = deviceDescriptor.deviceType_;
60 deviceRole_ = deviceDescriptor.deviceRole_;
61 audioStreamInfo_.channels = deviceDescriptor.audioStreamInfo_.channels;
62 audioStreamInfo_.encoding = deviceDescriptor.audioStreamInfo_.encoding;
63 audioStreamInfo_.format = deviceDescriptor.audioStreamInfo_.format;
64 audioStreamInfo_.samplingRate = deviceDescriptor.audioStreamInfo_.samplingRate;
65 channelMasks_ = deviceDescriptor.channelMasks_;
66 volumeGroupId_ = deviceDescriptor.volumeGroupId_;
67 interruptGroupId_ = deviceDescriptor.interruptGroupId_;
68 networkId_ = deviceDescriptor.networkId_;
69 }
70
~AudioDeviceDescriptor()71 AudioDeviceDescriptor::~AudioDeviceDescriptor()
72 {}
73
Marshalling(Parcel & parcel) const74 bool AudioDeviceDescriptor::Marshalling(Parcel &parcel) const
75 {
76 parcel.WriteInt32(deviceType_);
77 parcel.WriteInt32(deviceRole_);
78 parcel.WriteInt32(deviceId_);
79
80 parcel.WriteInt32(audioStreamInfo_.channels);
81 parcel.WriteInt32(audioStreamInfo_.encoding);
82 parcel.WriteInt32(audioStreamInfo_.format);
83 parcel.WriteInt32(audioStreamInfo_.samplingRate);
84 parcel.WriteInt32(channelMasks_);
85
86 parcel.WriteString(deviceName_);
87 parcel.WriteString(macAddress_);
88
89 parcel.WriteInt32(interruptGroupId_);
90 parcel.WriteInt32(volumeGroupId_);
91 parcel.WriteString(networkId_);
92 return true;
93 }
94
Unmarshalling(Parcel & in)95 sptr<AudioDeviceDescriptor> AudioDeviceDescriptor::Unmarshalling(Parcel &in)
96 {
97 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = new(std::nothrow) AudioDeviceDescriptor();
98 if (audioDeviceDescriptor == nullptr) {
99 return nullptr;
100 }
101
102 audioDeviceDescriptor->deviceType_ = static_cast<DeviceType>(in.ReadInt32());
103 audioDeviceDescriptor->deviceRole_ = static_cast<DeviceRole>(in.ReadInt32());
104 audioDeviceDescriptor->deviceId_ = in.ReadInt32();
105
106 audioDeviceDescriptor->audioStreamInfo_.channels = static_cast<AudioChannel>(in.ReadInt32());
107 audioDeviceDescriptor->audioStreamInfo_.encoding = static_cast<AudioEncodingType>(in.ReadInt32());
108 audioDeviceDescriptor->audioStreamInfo_.format = static_cast<AudioSampleFormat>(in.ReadInt32());
109 audioDeviceDescriptor->audioStreamInfo_.samplingRate = static_cast<AudioSamplingRate>(in.ReadInt32());
110 audioDeviceDescriptor->channelMasks_ = in.ReadInt32();
111
112 audioDeviceDescriptor->deviceName_ = in.ReadString();
113 audioDeviceDescriptor->macAddress_ = in.ReadString();
114
115 audioDeviceDescriptor->interruptGroupId_ = in.ReadInt32();
116 audioDeviceDescriptor->volumeGroupId_ = in.ReadInt32();
117 audioDeviceDescriptor->networkId_ = in.ReadString();
118
119 return audioDeviceDescriptor;
120 }
121
SetDeviceInfo(std::string deviceName,std::string macAddress)122 void AudioDeviceDescriptor::SetDeviceInfo(std::string deviceName, std::string macAddress)
123 {
124 deviceName_ = deviceName;
125 macAddress_ = macAddress;
126 }
127
SetDeviceCapability(const AudioStreamInfo & audioStreamInfo,int32_t channelMask)128 void AudioDeviceDescriptor::SetDeviceCapability(const AudioStreamInfo &audioStreamInfo, int32_t channelMask)
129 {
130 audioStreamInfo_.channels = audioStreamInfo.channels;
131 audioStreamInfo_.encoding = audioStreamInfo.encoding;
132 audioStreamInfo_.format = audioStreamInfo.format;
133 audioStreamInfo_.samplingRate = audioStreamInfo.samplingRate;
134 channelMasks_ = channelMask;
135 }
136
AudioRendererFilter()137 AudioRendererFilter::AudioRendererFilter()
138 {}
139
~AudioRendererFilter()140 AudioRendererFilter::~AudioRendererFilter()
141 {}
142
Marshalling(Parcel & parcel) const143 bool AudioRendererFilter::Marshalling(Parcel &parcel) const
144 {
145 return parcel.WriteInt32(uid)
146 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType))
147 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage))
148 && parcel.WriteInt32(static_cast<int32_t>(streamType))
149 && parcel.WriteInt32(rendererInfo.rendererFlags)
150 && parcel.WriteInt32(streamId);
151 }
152
Unmarshalling(Parcel & in)153 sptr<AudioRendererFilter> AudioRendererFilter::Unmarshalling(Parcel &in)
154 {
155 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
156 if (audioRendererFilter == nullptr) {
157 return nullptr;
158 }
159
160 audioRendererFilter->uid = in.ReadInt32();
161 audioRendererFilter->rendererInfo.contentType = static_cast<ContentType>(in.ReadInt32());
162 audioRendererFilter->rendererInfo.streamUsage = static_cast<StreamUsage>(in.ReadInt32());
163 audioRendererFilter->streamType = static_cast<AudioStreamType>(in.ReadInt32());
164 audioRendererFilter->rendererInfo.rendererFlags = in.ReadInt32();
165 audioRendererFilter->streamId = in.ReadInt32();
166
167 return audioRendererFilter;
168 }
169
AudioCapturerFilter()170 AudioCapturerFilter::AudioCapturerFilter()
171 {}
172
~AudioCapturerFilter()173 AudioCapturerFilter::~AudioCapturerFilter()
174 {}
175
Marshalling(Parcel & parcel) const176 bool AudioCapturerFilter::Marshalling(Parcel &parcel) const
177 {
178 return parcel.WriteInt32(uid);
179 }
180
Unmarshalling(Parcel & in)181 sptr<AudioCapturerFilter> AudioCapturerFilter::Unmarshalling(Parcel &in)
182 {
183 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
184 if (audioCapturerFilter == nullptr) {
185 return nullptr;
186 }
187
188 audioCapturerFilter->uid = in.ReadInt32();
189
190 return audioCapturerFilter;
191 }
192 } // namespace AudioStandard
193 } // namespace OHOS
194