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 #ifndef LOG_TAG
16 #define LOG_TAG "PolicyHandler"
17 #endif
18
19 #include "policy_handler.h"
20
21 #include <iomanip>
22 #include <thread>
23
24 #include "audio_errors.h"
25 #include "audio_common_log.h"
26 #include "audio_utils.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30 namespace {
31 const uint32_t FIRST_SESSIONID = 100000;
32 constexpr uint32_t MAX_VALID_SESSIONID = UINT32_MAX - FIRST_SESSIONID;
33 }
34
GetInstance()35 PolicyHandler& PolicyHandler::GetInstance()
36 {
37 static PolicyHandler PolicyHandler;
38
39 return PolicyHandler;
40 }
41
PolicyHandler()42 PolicyHandler::PolicyHandler()
43 {
44 AUDIO_INFO_LOG("PolicyHandler()");
45 }
46
~PolicyHandler()47 PolicyHandler::~PolicyHandler()
48 {
49 volumeVector_ = nullptr;
50 sharedAbsVolumeScene_ = nullptr;
51 policyVolumeMap_ = nullptr;
52 iPolicyProvider_ = nullptr;
53 AUDIO_INFO_LOG("~PolicyHandler()");
54 }
55
Dump(std::string & dumpString)56 void PolicyHandler::Dump(std::string &dumpString)
57 {
58 AUDIO_INFO_LOG("PolicyHandler dump begin");
59 if (iPolicyProvider_ == nullptr || policyVolumeMap_ == nullptr || volumeVector_ == nullptr) {
60 dumpString += "PolicyHandler is null...\n";
61 AUDIO_INFO_LOG("nothing to dump");
62 return;
63 }
64 // dump active output device
65 AppendFormat(dumpString, " - active output device: %d\n", deviceType_);
66 // dump volume
67 for (size_t i = 0; i < IPolicyProvider::GetVolumeVectorSize(); i++) {
68 AppendFormat(dumpString, " streamtype: %d ", g_volumeIndexVector[i].first);
69 AppendFormat(dumpString, " device: %d ", g_volumeIndexVector[i].second);
70 AppendFormat(dumpString, " isMute: %s ", (volumeVector_[i].isMute ? "true" : "false"));
71 AppendFormat(dumpString, " volFloat: %f ", volumeVector_[i].volumeFloat);
72 AppendFormat(dumpString, " volint: %u \n", volumeVector_[i].volumeInt);
73 }
74 if (sharedAbsVolumeScene_ == nullptr) {
75 dumpString += "sharedAbsVolumeScene_ is null...\n";
76 AUDIO_INFO_LOG("sharedAbsVolumeScene_ is null");
77 return;
78 }
79 AppendFormat(dumpString, " sharedAbsVolumeScene: %s \n", (*sharedAbsVolumeScene_ ? "true" : "false"));
80 }
81
ConfigPolicyProvider(const sptr<IPolicyProviderIpc> policyProvider)82 bool PolicyHandler::ConfigPolicyProvider(const sptr<IPolicyProviderIpc> policyProvider)
83 {
84 CHECK_AND_RETURN_RET_LOG(policyProvider != nullptr, false, "ConfigPolicyProvider failed with null provider.");
85 if (iPolicyProvider_ == nullptr) {
86 iPolicyProvider_ = policyProvider;
87 } else {
88 AUDIO_ERR_LOG("Provider is already configed!");
89 return false;
90 }
91 bool ret = InitVolumeMap();
92 AUDIO_INFO_LOG("ConfigPolicyProvider end and InitVolumeMap %{public}s", (ret ? "SUCCESS" : "FAILED"));
93 return ret;
94 }
95
GetProcessDeviceInfo(const AudioProcessConfig & config,bool lockFlag,AudioDeviceDescriptor & deviceInfo)96 bool PolicyHandler::GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag,
97 AudioDeviceDescriptor &deviceInfo)
98 {
99 // send the config to AudioPolicyServer and get the device info.
100 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, false, "GetProcessDeviceInfo failed with null provider.");
101 int32_t ret = iPolicyProvider_->GetProcessDeviceInfo(config, lockFlag, deviceInfo);
102 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, false, "GetProcessDeviceInfo failed:%{public}d", ret);
103 return true;
104 }
105
InitVolumeMap()106 bool PolicyHandler::InitVolumeMap()
107 {
108 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, false, "InitVolumeMap failed with null provider.");
109 iPolicyProvider_->InitSharedVolume(policyVolumeMap_);
110 CHECK_AND_RETURN_RET_LOG((policyVolumeMap_ != nullptr && policyVolumeMap_->GetBase() != nullptr), false,
111 "InitSharedVolume failed.");
112 size_t mapSize = IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume) + sizeof(bool);
113 CHECK_AND_RETURN_RET_LOG(policyVolumeMap_->GetSize() == mapSize, false,
114 "InitSharedVolume get error size:%{public}zu, target:%{public}zu", policyVolumeMap_->GetSize(), mapSize);
115 volumeVector_ = reinterpret_cast<Volume *>(policyVolumeMap_->GetBase());
116 sharedAbsVolumeScene_ = reinterpret_cast<bool *>(policyVolumeMap_->GetBase()) +
117 IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume);
118 AUDIO_INFO_LOG("InitSharedVolume success.");
119 return true;
120 }
121
GetSharedVolume(AudioVolumeType streamType,DeviceType deviceType,Volume & vol)122 bool PolicyHandler::GetSharedVolume(AudioVolumeType streamType, DeviceType deviceType, Volume &vol)
123 {
124 CHECK_AND_RETURN_RET_LOG((iPolicyProvider_ != nullptr && volumeVector_ != nullptr), false,
125 "GetSharedVolume failed not configed");
126 size_t index = 0;
127 if (!IPolicyProvider::GetVolumeIndex(streamType, GetVolumeGroupForDevice(deviceType), index) ||
128 index >= IPolicyProvider::GetVolumeVectorSize()) {
129 return false;
130 }
131 vol.isMute = volumeVector_[index].isMute;
132 vol.volumeFloat = volumeVector_[index].volumeFloat;
133 vol.volumeInt = volumeVector_[index].volumeInt;
134 return true;
135 }
136
SetActiveOutputDevice(DeviceType deviceType)137 void PolicyHandler::SetActiveOutputDevice(DeviceType deviceType)
138 {
139 AUDIO_INFO_LOG("SetActiveOutputDevice to device[%{public}d].", deviceType);
140 deviceType_ = deviceType;
141 }
142
143 std::atomic<uint32_t> g_sessionId = {FIRST_SESSIONID}; // begin at 100000
144
GenerateSessionId(int32_t uid)145 uint32_t PolicyHandler::GenerateSessionId(int32_t uid)
146 {
147 uint32_t sessionId = g_sessionId++;
148 AUDIO_INFO_LOG("uid:%{public}d sessionId:%{public}d", uid, sessionId);
149 if (g_sessionId > MAX_VALID_SESSIONID) {
150 AUDIO_WARNING_LOG("sessionId is too large, reset it!");
151 g_sessionId = FIRST_SESSIONID;
152 }
153 return sessionId;
154 }
155
GetActiveOutPutDevice()156 DeviceType PolicyHandler::GetActiveOutPutDevice()
157 {
158 return deviceType_;
159 }
160
SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig & config)161 int32_t PolicyHandler::SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config)
162 {
163 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
164 int32_t ret = iPolicyProvider_->SetWakeUpAudioCapturerFromAudioServer(config);
165 return ret;
166 }
167
NotifyCapturerAdded(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint32_t sessionId)168 int32_t PolicyHandler::NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo,
169 uint32_t sessionId)
170 {
171 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
172 return iPolicyProvider_->NotifyCapturerAdded(capturerInfo, streamInfo, sessionId);
173 }
174
NotifyWakeUpCapturerRemoved()175 int32_t PolicyHandler::NotifyWakeUpCapturerRemoved()
176 {
177 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
178 return iPolicyProvider_->NotifyWakeUpCapturerRemoved();
179 }
180
IsAbsVolumeSupported()181 bool PolicyHandler::IsAbsVolumeSupported()
182 {
183 CHECK_AND_RETURN_RET_LOG((iPolicyProvider_ != nullptr && sharedAbsVolumeScene_ != nullptr), false,
184 "abs volume scene failed not configed");
185
186 return *sharedAbsVolumeScene_;
187 }
188
OffloadGetRenderPosition(uint32_t & delayValue,uint64_t & sendDataSize,uint32_t & timeStamp)189 int32_t PolicyHandler::OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp)
190 {
191 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
192 return iPolicyProvider_->OffloadGetRenderPosition(delayValue, sendDataSize, timeStamp);
193 }
194
GetHighResolutionExist()195 bool PolicyHandler::GetHighResolutionExist()
196 {
197 return isHighResolutionExist_;
198 }
199
SetHighResolutionExist(bool isHighResExist)200 void PolicyHandler::SetHighResolutionExist(bool isHighResExist)
201 {
202 isHighResolutionExist_ = isHighResExist;
203 }
204
GetAndSaveClientType(uint32_t uid,const std::string & bundleName)205 int32_t PolicyHandler::GetAndSaveClientType(uint32_t uid, const std::string &bundleName)
206 {
207 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
208 return iPolicyProvider_->GetAndSaveClientType(uid, bundleName);
209 }
210
GetMaxRendererInstances()211 int32_t PolicyHandler::GetMaxRendererInstances()
212 {
213 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
214 return iPolicyProvider_->GetMaxRendererInstances();
215 }
216
ActivateConcurrencyFromServer(AudioPipeType incomingPipe)217 int32_t PolicyHandler::ActivateConcurrencyFromServer(AudioPipeType incomingPipe)
218 {
219 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
220 return iPolicyProvider_->ActivateConcurrencyFromServer(incomingPipe);
221 }
222 } // namespace AudioStandard
223 } // namespace OHOS
224