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,DeviceInfo & deviceInfo)96 bool PolicyHandler::GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag, DeviceInfo &deviceInfo)
97 {
98 // send the config to AudioPolicyServer and get the device info.
99 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, false, "GetProcessDeviceInfo failed with null provider.");
100 int32_t ret = iPolicyProvider_->GetProcessDeviceInfo(config, lockFlag, deviceInfo);
101 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, false, "GetProcessDeviceInfo failed:%{public}d", ret);
102 return true;
103 }
104
InitVolumeMap()105 bool PolicyHandler::InitVolumeMap()
106 {
107 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, false, "InitVolumeMap failed with null provider.");
108 iPolicyProvider_->InitSharedVolume(policyVolumeMap_);
109 CHECK_AND_RETURN_RET_LOG((policyVolumeMap_ != nullptr && policyVolumeMap_->GetBase() != nullptr), false,
110 "InitSharedVolume failed.");
111 size_t mapSize = IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume) + sizeof(bool);
112 CHECK_AND_RETURN_RET_LOG(policyVolumeMap_->GetSize() == mapSize, false,
113 "InitSharedVolume get error size:%{public}zu, target:%{public}zu", policyVolumeMap_->GetSize(), mapSize);
114 volumeVector_ = reinterpret_cast<Volume *>(policyVolumeMap_->GetBase());
115 sharedAbsVolumeScene_ = reinterpret_cast<bool *>(policyVolumeMap_->GetBase()) +
116 IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume);
117 AUDIO_INFO_LOG("InitSharedVolume success.");
118 return true;
119 }
120
GetSharedVolume(AudioVolumeType streamType,DeviceType deviceType,Volume & vol)121 bool PolicyHandler::GetSharedVolume(AudioVolumeType streamType, DeviceType deviceType, Volume &vol)
122 {
123 CHECK_AND_RETURN_RET_LOG((iPolicyProvider_ != nullptr && volumeVector_ != nullptr), false,
124 "GetSharedVolume failed not configed");
125 size_t index = 0;
126 if (!IPolicyProvider::GetVolumeIndex(streamType, GetVolumeGroupForDevice(deviceType), index) ||
127 index >= IPolicyProvider::GetVolumeVectorSize()) {
128 return false;
129 }
130 vol.isMute = volumeVector_[index].isMute;
131 vol.volumeFloat = volumeVector_[index].volumeFloat;
132 vol.volumeInt = volumeVector_[index].volumeInt;
133 return true;
134 }
135
SetActiveOutputDevice(DeviceType deviceType)136 void PolicyHandler::SetActiveOutputDevice(DeviceType deviceType)
137 {
138 AUDIO_INFO_LOG("SetActiveOutputDevice to device[%{public}d].", deviceType);
139 deviceType_ = deviceType;
140 }
141
142 std::atomic<uint32_t> g_sessionId = {FIRST_SESSIONID}; // begin at 100000
143
GenerateSessionId(int32_t uid)144 uint32_t PolicyHandler::GenerateSessionId(int32_t uid)
145 {
146 uint32_t sessionId = g_sessionId++;
147 AUDIO_INFO_LOG("uid:%{public}d sessionId:%{public}d", uid, sessionId);
148 if (g_sessionId > MAX_VALID_SESSIONID) {
149 AUDIO_WARNING_LOG("sessionId is too large, reset it!");
150 g_sessionId = FIRST_SESSIONID;
151 }
152 return sessionId;
153 }
154
GetActiveOutPutDevice()155 DeviceType PolicyHandler::GetActiveOutPutDevice()
156 {
157 return deviceType_;
158 }
159
SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig & config)160 int32_t PolicyHandler::SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config)
161 {
162 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
163 int32_t ret = iPolicyProvider_->SetWakeUpAudioCapturerFromAudioServer(config);
164 return ret;
165 }
166
NotifyCapturerAdded(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint32_t sessionId)167 int32_t PolicyHandler::NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo,
168 uint32_t sessionId)
169 {
170 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
171 return iPolicyProvider_->NotifyCapturerAdded(capturerInfo, streamInfo, sessionId);
172 }
173
NotifyWakeUpCapturerRemoved()174 int32_t PolicyHandler::NotifyWakeUpCapturerRemoved()
175 {
176 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
177 return iPolicyProvider_->NotifyWakeUpCapturerRemoved();
178 }
179
IsAbsVolumeSupported()180 bool PolicyHandler::IsAbsVolumeSupported()
181 {
182 CHECK_AND_RETURN_RET_LOG((iPolicyProvider_ != nullptr && sharedAbsVolumeScene_ != nullptr), false,
183 "abs volume scene failed not configed");
184
185 return *sharedAbsVolumeScene_;
186 }
187
OffloadGetRenderPosition(uint32_t & delayValue,uint64_t & sendDataSize,uint32_t & timeStamp)188 int32_t PolicyHandler::OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp)
189 {
190 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
191 return iPolicyProvider_->OffloadGetRenderPosition(delayValue, sendDataSize, timeStamp);
192 }
193
GetHighResolutionExist()194 bool PolicyHandler::GetHighResolutionExist()
195 {
196 return isHighResolutionExist_;
197 }
198
SetHighResolutionExist(bool isHighResExist)199 void PolicyHandler::SetHighResolutionExist(bool isHighResExist)
200 {
201 isHighResolutionExist_ = isHighResExist;
202 }
203
GetAndSaveClientType(uint32_t uid,const std::string & bundleName)204 int32_t PolicyHandler::GetAndSaveClientType(uint32_t uid, const std::string &bundleName)
205 {
206 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
207 return iPolicyProvider_->GetAndSaveClientType(uid, bundleName);
208 }
209
GetMaxRendererInstances()210 int32_t PolicyHandler::GetMaxRendererInstances()
211 {
212 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
213 return iPolicyProvider_->GetMaxRendererInstances();
214 }
215
ActivateConcurrencyFromServer(AudioPipeType incomingPipe)216 int32_t PolicyHandler::ActivateConcurrencyFromServer(AudioPipeType incomingPipe)
217 {
218 CHECK_AND_RETURN_RET_LOG(iPolicyProvider_ != nullptr, ERROR, "iPolicyProvider_ is nullptr");
219 return iPolicyProvider_->ActivateConcurrencyFromServer(incomingPipe);
220 }
221 } // namespace AudioStandard
222 } // namespace OHOS
223