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 #ifndef AUDIO_CAPTURER_PRIVATE_H
17 #define AUDIO_CAPTURER_PRIVATE_H
18 
19 #include <mutex>
20 #include <shared_mutex>
21 #include "audio_utils.h"
22 #include "audio_concurrency_callback.h"
23 #include "audio_interrupt_callback.h"
24 #include "i_audio_stream.h"
25 #include "audio_capturer_proxy_obj.h"
26 
27 namespace OHOS {
28 namespace AudioStandard {
29 constexpr uint32_t INVALID_SESSION_ID = static_cast<uint32_t>(-1);
30 class AudioCapturerStateChangeCallbackImpl;
31 class CapturerPolicyServiceDiedCallback;
32 class InputDeviceChangeWithInfoCallbackImpl;
33 class AudioCapturerConcurrencyCallbackImpl;
34 
35 class AudioCapturerPrivate : public AudioCapturer {
36 public:
37     int32_t GetFrameCount(uint32_t &frameCount) const override;
38     int32_t SetParams(const AudioCapturerParams params) override;
39     int32_t UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config) override;
40     int32_t SetCapturerCallback(const std::shared_ptr<AudioCapturerCallback> &callback) override;
41     int32_t GetParams(AudioCapturerParams &params) const override;
42     int32_t GetCapturerInfo(AudioCapturerInfo &capturerInfo) const override;
43     int32_t GetStreamInfo(AudioStreamInfo &streamInfo) const override;
44     bool Start() const override;
45     int32_t  Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) const override;
46     CapturerState GetStatus() const override;
47     bool GetAudioTime(Timestamp &timestamp, Timestamp::Timestampbase base) const override;
48     bool Pause() const override;
49     bool Stop() const override;
50     bool Flush() const override;
51     bool Release() override;
52     int32_t GetBufferSize(size_t &bufferSize) const override;
53     int32_t GetAudioStreamId(uint32_t &sessionID) const override;
54     int32_t SetCapturerPositionCallback(int64_t markPosition,
55         const std::shared_ptr<CapturerPositionCallback> &callback) override;
56     void UnsetCapturerPositionCallback() override;
57     int32_t SetCapturerPeriodPositionCallback(int64_t frameNumber,
58         const std::shared_ptr<CapturerPeriodPositionCallback> &callback) override;
59     void UnsetCapturerPeriodPositionCallback() override;
60     int32_t SetBufferDuration(uint64_t bufferDuration) const override;
61     int32_t SetCaptureMode(AudioCaptureMode renderMode) override;
62     AudioCaptureMode GetCaptureMode()const override;
63     int32_t SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) override;
64     int32_t GetBufferDesc(BufferDesc &bufDesc)const override;
65     int32_t Enqueue(const BufferDesc &bufDesc)const override;
66     int32_t Clear()const override;
67     int32_t GetBufQueueState(BufferQueueState &bufState)const override;
68     void SetApplicationCachePath(const std::string cachePath) override;
69     void SetValid(bool valid) override;
70     int64_t GetFramesRead() const override;
71     int32_t GetCurrentInputDevices(DeviceInfo &deviceInfo) const override;
72     int32_t GetCurrentCapturerChangeInfo(AudioCapturerChangeInfo &changeInfo) const override;
73     int32_t SetAudioCapturerDeviceChangeCallback(
74         const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback) override;
75     int32_t RemoveAudioCapturerDeviceChangeCallback(
76         const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback) override;
77     int32_t SetAudioCapturerInfoChangeCallback(
78         const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback) override;
79     int32_t RemoveAudioCapturerInfoChangeCallback(
80         const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback) override;
81     int32_t RegisterAudioCapturerEventListener() override;
82     int32_t UnregisterAudioCapturerEventListener() override;
83 
84     int32_t RegisterCapturerPolicyServiceDiedCallback();
85     int32_t RemoveCapturerPolicyServiceDiedCallback();
86 
87     bool IsDeviceChanged(DeviceInfo &newDeviceInfo);
88     std::vector<sptr<MicrophoneDescriptor>> GetCurrentMicrophones() const override;
89 
90     void GetAudioInterrupt(AudioInterrupt &audioInterrupt);
91 
92     uint32_t GetOverflowCount() const override;
93 
94     void SwitchStream(const uint32_t sessionId, const int32_t streamFlag,
95         const AudioStreamDeviceChangeReasonExt reason);
96 
97     int32_t SetAudioSourceConcurrency(const std::vector<SourceType> &targetSources) override;
98 
99     void ConcedeStream();
100 
101     std::shared_ptr<IAudioStream> audioStream_;
102     AudioCapturerInfo capturerInfo_ = {};
103     AudioPlaybackCaptureConfig filterConfig_ = {{{}, FilterMode::INCLUDE, {}, FilterMode::INCLUDE}, false};
104     AudioStreamType audioStreamType_;
105     std::string cachePath_;
106     bool abortRestore_ = false;
107     AudioSessionStrategy strategy_ = { AudioConcurrencyMode::INVALID };
108 
109     AudioCapturerPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream = true);
110     virtual ~AudioCapturerPrivate();
111     bool isChannelChange_ = false;
112     int32_t InitPlaybackCapturer(int32_t type, const AudioPlaybackCaptureConfig &config);
113     int32_t SetCaptureSilentState(bool state) override;
ConvertToAudioStreamParams(const AudioCapturerParams params)114     static inline AudioStreamParams ConvertToAudioStreamParams(const AudioCapturerParams params)
115     {
116         AudioStreamParams audioStreamParams;
117 
118         audioStreamParams.format = params.audioSampleFormat;
119         audioStreamParams.samplingRate = params.samplingRate;
120         audioStreamParams.channels = params.audioChannel;
121         audioStreamParams.encoding = params.audioEncoding;
122         audioStreamParams.channelLayout = params.channelLayout;
123 
124         return audioStreamParams;
125     }
126 
127 private:
128     int32_t InitAudioInterruptCallback();
129     int32_t InitInputDeviceChangeCallback();
130     void SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream);
131     bool SwitchToTargetStream(IAudioStream::StreamClass targetClass, uint32_t &newSessionId);
132     void InitLatencyMeasurement(const AudioStreamParams &audioStreamParams);
133     int32_t InitAudioStream(const AudioStreamParams &AudioStreamParams);
134     int32_t InitAudioConcurrencyCallback();
135     void CheckSignalData(uint8_t *buffer, size_t bufferSize) const;
136     void ActivateAudioConcurrency(IAudioStream::StreamClass &streamClass);
137     IAudioStream::StreamClass GetPreferredStreamClass(AudioStreamParams audioStreamParams);
138     std::shared_ptr<InputDeviceChangeWithInfoCallbackImpl> inputDeviceChangeCallback_ = nullptr;
139     bool isSwitching_ = false;
140     mutable std::shared_mutex switchStreamMutex_;
141     void WriteOverflowEvent() const;
142     std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr;
143     std::shared_ptr<AudioInterruptCallback> audioInterruptCallback_ = nullptr;
144     AppInfo appInfo_ = {};
145     AudioInterrupt audioInterrupt_ = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN,
146         {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, false}, 0};
147     bool isVoiceCallCapturer_ = false;
148     uint32_t sessionID_ = INVALID_SESSION_ID;
149     std::shared_ptr<AudioCapturerProxyObj> capturerProxyObj_;
150     static std::map<AudioStreamType, SourceType> streamToSource_;
151     std::mutex lock_;
152     bool isValid_ = true;
153     std::shared_ptr<AudioCapturerStateChangeCallbackImpl> audioStateChangeCallback_ = nullptr;
154     std::shared_ptr<CapturerPolicyServiceDiedCallback> audioPolicyServiceDiedCallback_ = nullptr;
155     std::shared_ptr<AudioCapturerConcurrencyCallbackImpl> audioConcurrencyCallback_ = nullptr;
156     DeviceInfo currentDeviceInfo_ = {};
157     bool latencyMeasEnabled_ = false;
158     std::shared_ptr<SignalDetectAgent> signalDetectAgent_ = nullptr;
159     mutable std::mutex signalDetectAgentMutex_;
160     FILE *dumpFile_ = nullptr;
161     AudioCaptureMode audioCaptureMode_ = CAPTURE_MODE_NORMAL;
162     bool isFastVoipSupported_ = false;
163     std::mutex setCapturerCbMutex_;
164     std::mutex setParamsMutex_;
165 };
166 
167 class AudioCapturerInterruptCallbackImpl : public AudioInterruptCallback {
168 public:
169     explicit AudioCapturerInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream);
170     virtual ~AudioCapturerInterruptCallbackImpl();
171 
172     void OnInterrupt(const InterruptEventInternal &interruptEvent) override;
173     void SaveCallback(const std::weak_ptr<AudioCapturerCallback> &callback);
174     void UpdateAudioStream(const std::shared_ptr<IAudioStream> &audioStream);
175 private:
176     void NotifyEvent(const InterruptEvent &interruptEvent);
177     void HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent);
178     void NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent);
179     std::shared_ptr<IAudioStream> audioStream_;
180     std::weak_ptr<AudioCapturerCallback> callback_;
181     bool isForcePaused_ = false;
182     std::shared_ptr<AudioCapturerCallback> cb_;
183     std::mutex mutex_;
184 };
185 
186 class AudioStreamCallbackCapturer : public AudioStreamCallback {
187 public:
188     virtual ~AudioStreamCallbackCapturer() = default;
189 
190     void OnStateChange(const State state, const StateChangeCmdType __attribute__((unused)) cmdType) override;
191     void SaveCallback(const std::weak_ptr<AudioCapturerCallback> &callback);
192 private:
193     std::weak_ptr<AudioCapturerCallback> callback_;
194 };
195 
196 class AudioCapturerStateChangeCallbackImpl : public AudioCapturerStateChangeCallback {
197 public:
198     AudioCapturerStateChangeCallbackImpl();
199     virtual ~AudioCapturerStateChangeCallbackImpl();
200 
201     void OnCapturerStateChange(
202         const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override;
203     void SaveDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback);
204     void RemoveDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback);
205     int32_t DeviceChangeCallbackArraySize();
206     void SaveCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback);
207     void RemoveCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback);
208     int32_t GetCapturerInfoChangeCallbackArraySize();
209     void setAudioCapturerObj(AudioCapturerPrivate *capturerObj);
210     void NotifyAudioCapturerDeviceChange(
211         const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
212     void NotifyAudioCapturerInfoChange(
213         const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos);
214     void HandleCapturerDestructor();
215 private:
216     std::vector<std::shared_ptr<AudioCapturerDeviceChangeCallback>> deviceChangeCallbacklist_;
217     std::vector<std::shared_ptr<AudioCapturerInfoChangeCallback>> capturerInfoChangeCallbacklist_;
218     std::mutex capturerMutex_;
219     AudioCapturerPrivate *capturer_{nullptr};
220 };
221 
222 class InputDeviceChangeWithInfoCallbackImpl : public DeviceChangeWithInfoCallback {
223 public:
224     InputDeviceChangeWithInfoCallbackImpl() = default;
225 
226     virtual ~InputDeviceChangeWithInfoCallbackImpl() = default;
227 
228     void OnDeviceChangeWithInfo(
229         const uint32_t sessionId, const DeviceInfo &deviceInfo, const AudioStreamDeviceChangeReasonExt reason) override;
230 
231     void OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag,
232         const AudioStreamDeviceChangeReasonExt reason) override;
233 
SetAudioCapturerObj(AudioCapturerPrivate * capturerObj)234     void SetAudioCapturerObj(AudioCapturerPrivate * capturerObj)
235     {
236         std::lock_guard<std::mutex> lock(mutex_);
237         capturer_ = capturerObj;
238     }
239 
UnsetAudioCapturerObj()240     void UnsetAudioCapturerObj()
241     {
242         std::lock_guard<std::mutex> lock(mutex_);
243         capturer_ = nullptr;
244     }
245 private:
246     AudioCapturerPrivate *capturer_;
247     std::mutex mutex_;
248 };
249 
250 class CapturerPolicyServiceDiedCallback : public AudioStreamPolicyServiceDiedCallback {
251 public:
252     CapturerPolicyServiceDiedCallback();
253     virtual ~CapturerPolicyServiceDiedCallback();
254     void SetAudioCapturerObj(AudioCapturerPrivate *capturerObj);
255     void SetAudioInterrupt(AudioInterrupt &audioInterrupt);
256     void OnAudioPolicyServiceDied() override;
257 
258 private:
259     AudioCapturerPrivate *capturer_ = nullptr;
260     AudioInterrupt audioInterrupt_;
261     void RestoreTheadLoop();
262     std::unique_ptr<std::thread> restoreThread_ = nullptr;
263 };
264 
265 class AudioCapturerConcurrencyCallbackImpl : public AudioConcurrencyCallback {
266 public:
267     explicit AudioCapturerConcurrencyCallbackImpl();
268     virtual ~AudioCapturerConcurrencyCallbackImpl();
269     void OnConcedeStream() override;
SetAudioCapturerObj(AudioCapturerPrivate * rendererObj)270     void SetAudioCapturerObj(AudioCapturerPrivate *rendererObj)
271     {
272         std::lock_guard<std::mutex> lock(mutex_);
273         capturer_ = rendererObj;
274     }
UnsetAudioCapturerObj()275     void UnsetAudioCapturerObj()
276     {
277         std::lock_guard<std::mutex> lock(mutex_);
278         capturer_ = nullptr;
279     }
280 private:
281     AudioCapturerPrivate *capturer_ = nullptr;
282     std::mutex mutex_;
283 };
284 }  // namespace AudioStandard
285 }  // namespace OHOS
286 
287 #endif // AUDIO_CAPTURER_PRIVATE_H
288