1 /*
2  * Copyright (c) 2023 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_SERVICE_H
17 #define AUDIO_SERVICE_H
18 
19 #include <condition_variable>
20 #include <sstream>
21 #include <set>
22 #include <map>
23 #include <mutex>
24 #include <vector>
25 
26 #include "audio_process_in_server.h"
27 #include "audio_endpoint.h"
28 #include "ipc_stream_in_server.h"
29 #include "playback_capturer_manager.h"
30 
31 namespace OHOS {
32 namespace AudioStandard {
33 namespace {
34 enum InnerCapFilterPolicy : uint32_t {
35     POLICY_INVALID = 0,
36     POLICY_USAGES_ONLY,
37     POLICY_USAGES_AND_PIDS
38 };
39 } // anonymous namespace
40 
41 class AudioService : public ProcessReleaseCallback, public ICapturerFilterListener {
42 public:
43     static AudioService *GetInstance();
44     ~AudioService();
45 
46     // override for ICapturerFilterListener
47     int32_t OnCapturerFilterChange(uint32_t sessionId, const AudioPlaybackCaptureConfig &newConfig) override;
48     int32_t OnCapturerFilterRemove(uint32_t sessionId) override;
49 
50     sptr<IpcStreamInServer> GetIpcStream(const AudioProcessConfig &config, int32_t &ret);
51 
52     sptr<AudioProcessInServer> GetAudioProcess(const AudioProcessConfig &config);
53     // override for ProcessReleaseCallback, do release process work.
54     int32_t OnProcessRelease(IAudioProcessStream *process, bool isSwitchStream = false) override;
55     void ReleaseProcess(const std::string endpointName, const int32_t delayTime);
56 
57     DeviceInfo GetDeviceInfoForProcess(const AudioProcessConfig &config);
58     std::shared_ptr<AudioEndpoint> GetAudioEndpointForDevice(DeviceInfo &deviceInfo,
59         const AudioProcessConfig &clientConfig, bool isVoipStream);
60     int32_t NotifyStreamVolumeChanged(AudioStreamType streamType, float volume);
61 
62     int32_t LinkProcessToEndpoint(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint);
63     int32_t UnlinkProcessToEndpoint(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint);
64     void Dump(std::string &dumpString);
65     float GetMaxAmplitude(bool isOutputDevice);
66     void ResetAudioEndpoint();
67 
68     void RemoveRenderer(uint32_t sessionId);
69     void RemoveCapturer(uint32_t sessionId);
70     int32_t EnableDualToneList(uint32_t sessionId);
71     int32_t DisableDualToneList(uint32_t sessionId);
72     std::shared_ptr<RendererInServer> GetRendererBySessionID(const uint32_t &session);
73     void SetNonInterruptMute(const uint32_t SessionId, const bool muteFlag);
74     void UpdateMuteControlSet(uint32_t sessionId, bool muteFlag);
75 
76     int32_t UpdateSourceType(SourceType sourceType);
77     void SetIncMaxRendererStreamCnt(AudioMode audioMode);
78     int32_t GetCurrentRendererStreamCnt();
79     void SetDecMaxRendererStreamCnt();
80     bool IsExceedingMaxStreamCntPerUid(int32_t callingUid, int32_t appUid, int32_t maxStreamCntPerUid);
81     void GetCreatedAudioStreamMostUid(int32_t &mostAppUid, int32_t &mostAppNum);
82     void CleanAppUseNumMap(int32_t appUid);
83 
84 private:
85     AudioService();
86     void DelayCallReleaseEndpoint(std::string endpointName, int32_t delayInMs);
87 
88     void InsertRenderer(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer);
89     void InsertCapturer(uint32_t sessionId, std::shared_ptr<CapturerInServer> capturer);
90     // for inner-capturer
91     void CheckInnerCapForRenderer(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer);
92     void CheckInnerCapForProcess(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint);
93     void FilterAllFastProcess();
94     InnerCapFilterPolicy GetInnerCapFilterPolicy();
95     bool ShouldBeInnerCap(const AudioProcessConfig &rendererConfig);
96     bool ShouldBeDualTone(const AudioProcessConfig &config);
97     int32_t OnInitInnerCapList(); // for first InnerCap filter take effect.
98     int32_t OnUpdateInnerCapList(); // for some InnerCap filter has already take effect.
99     bool IsEndpointTypeVoip(const AudioProcessConfig &config, DeviceInfo &deviceInfo);
100     void RemoveIdFromMuteControlSet(uint32_t sessionId);
101     void CheckRenderSessionMuteState(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer);
102     void CheckCaptureSessionMuteState(uint32_t sessionId, std::shared_ptr<CapturerInServer> capturer);
103     void CheckFastSessionMuteState(uint32_t sessionId, sptr<AudioProcessInServer> process);
104     int32_t GetReleaseDelayTime(std::shared_ptr<AudioEndpoint> endpoint, bool isSwitchStream);
105     void ReLinkProcessToEndpoint();
106 
107 private:
108     std::mutex processListMutex_;
109     std::vector<std::pair<sptr<AudioProcessInServer>, std::shared_ptr<AudioEndpoint>>> linkedPairedList_;
110 
111     std::mutex releaseEndpointMutex_;
112     std::condition_variable releaseEndpointCV_;
113     std::set<std::string> releasingEndpointSet_;
114     std::map<std::string, std::shared_ptr<AudioEndpoint>> endpointList_;
115 
116     // for inner-capturer
117     PlaybackCapturerManager *innerCapturerMgr_ = nullptr;
118     uint32_t workingInnerCapId_ = 0; // invalid sessionId
119     uint32_t workingDualToneId_ = 0; // invalid sessionId
120     AudioPlaybackCaptureConfig workingConfig_;
121 
122     std::mutex rendererMapMutex_;
123     std::mutex capturerMapMutex_;
124     std::vector<std::weak_ptr<RendererInServer>> filteredRendererMap_ = {};
125     std::map<uint32_t, std::weak_ptr<RendererInServer>> allRendererMap_ = {};
126     std::map<uint32_t, std::weak_ptr<CapturerInServer>> allCapturerMap_ = {};
127 
128     std::vector<std::weak_ptr<RendererInServer>> filteredDualToneRendererMap_ = {};
129 
130     std::mutex mutedSessionsMutex_;
131     std::set<uint32_t> mutedSessions_ = {};
132     int32_t currentRendererStreamCnt_ = 0;
133     std::mutex streamLifeCycleMutex_ {};
134     std::map<int32_t, std::int32_t> appUseNumMap_;
135 };
136 } // namespace AudioStandard
137 } // namespace OHOS
138 #endif // AUDIO_SERVICE_H
139