diff --git a/frameworks/native/audiopolicy/include/audio_policy_manager.h b/frameworks/native/audiopolicy/include/audio_policy_manager.h index c02ab69db6940d4f276a4cb79969ec5ebe194200..e576f9299b46b1ff2823e8d4650125aba4a6caed 100644 --- a/frameworks/native/audiopolicy/include/audio_policy_manager.h +++ b/frameworks/native/audiopolicy/include/audio_policy_manager.h @@ -78,6 +78,8 @@ public: AudioStreamType GetSystemActiveVolumeType(const int32_t clientUid); + bool ReloadLoudVolumeMode(AudioStreamType streamType, SetLoudVolMode setVolMode); + int32_t GetSystemVolumeLevel(AudioVolumeType volumeType, int32_t uid = 0); int32_t GetAppVolumeLevel(int32_t appUid, int32_t &volumeLevel); diff --git a/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h b/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h index 4ffec5d6ee26606629b4bd750e3a7d870f7add42..1cf391a400ce0e15a550705420e91875b6de16cd 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h @@ -558,15 +558,10 @@ const std::vector AUDIO_SUPPORTED_STREAM_USAGES { STREAM_USAGE_VOICE_CALL_ASSISTANT, }; -enum FunctionHoldType { - FUNCTION_HOLD_INVALID = -1, - FUNCTION_HOLD_MUSIC, - FUNCTION_HOLD_SYSTEM, -}; - enum SetLoudVolMode { LOUD_VOLUME_SWITCH_INVALID = -1, - LOUD_VOLUME_SWITCH_UNSET, + LOUD_VOLUME_SWITCH_AUTO, + LOUD_VOLUME_SWITCH_PAUSE, LOUD_VOLUME_SWITCH_OFF, LOUD_VOLUME_SWITCH_ON, }; diff --git a/services/audio_policy/BUILD.gn b/services/audio_policy/BUILD.gn index bc4bd63a6419981553b04df3dbadaab3da89c842..199bf12cc59f947da90850138027b6f7c6c46c29 100644 --- a/services/audio_policy/BUILD.gn +++ b/services/audio_policy/BUILD.gn @@ -263,6 +263,7 @@ audio_ohos_library("audio_policy_service") { "server/domain/device/src/audio_scene_manager.cpp", "server/domain/tone/audio_tone_manager.cpp", "server/domain/volume/src/audio_volume_manager.cpp", + "server/domain/volume/src/audio_loud_volume_manager.cpp", "server/domain/device/src/sle/sle_audio_device_manager.cpp", "server/domain/device/src/va/va_device_manager.cpp", "client/stub/src/va_device_broker_stub_impl.cpp", diff --git a/services/audio_policy/client/service/src/audio_policy_manager.cpp b/services/audio_policy/client/service/src/audio_policy_manager.cpp index 61cbb8c96a9e6017f74b6a637d2dab6991ad7bce..5a5ef4329b9dddfd10ca7e12b2a6c8cec873000c 100644 --- a/services/audio_policy/client/service/src/audio_policy_manager.cpp +++ b/services/audio_policy/client/service/src/audio_policy_manager.cpp @@ -476,6 +476,15 @@ AudioStreamType AudioPolicyManager::GetSystemActiveVolumeType(const int32_t clie return static_cast(streamType); } +bool AudioPolicyManager::ReloadLoudVolumeMode(AudioStreamType streamType, SetLoudVolMode setVolMode) +{ + const sptr gsp = GetAudioPolicyManagerProxy(); + CHECK_AND_RETURN_RET_LOG(gsp != nullptr, false, "audio policy manager proxy is NULL."); + bool ret = false; + gsp->ReloadLoudVolumeMode(static_cast(streamType), static_cast(setVolMode), ret); + return ret; +} + int32_t AudioPolicyManager::GetSelfAppVolumeLevel(int32_t &volumeLevel) { const sptr gsp = GetAudioPolicyManagerProxy(); diff --git a/services/audio_policy/idl/IAudioPolicy.idl b/services/audio_policy/idl/IAudioPolicy.idl index c4d922a041388611c106b5eaf491bba6ee412154..c18a0a3d07b9177203457a1d36997b5b33878f0c 100644 --- a/services/audio_policy/idl/IAudioPolicy.idl +++ b/services/audio_policy/idl/IAudioPolicy.idl @@ -306,5 +306,6 @@ interface IAudioPolicy { void PreferBluetoothAndNearlinkRecord([in] boolean isPreferred); void GetPreferBluetoothAndNearlinkRecord([out] boolean isPreferred); void RestoreOutputDevice([in] sptr audioRendererFilter); + void ReloadLoudVolumeMode([in] int streamInFocus, [in] int setVolMode, [out] boolean ret); } diff --git a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp index 2629945c923b507401e3c6cf1a35f19849afdf6b..3796a938da8762cdd0ab399403fa86e2380dd9e0 100644 --- a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp +++ b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp @@ -922,10 +922,6 @@ int32_t AudioInterruptService::ActivateAudioInterruptInternal(const int32_t zone incomingStreamId, currAudioInterrupt.pid, streamType, zoneId, currAudioInterrupt.streamUsage, (currAudioInterrupt.audioFocusType).sourceType); -#ifdef FEATURE_MULTIMODALINPUT_INPUT - CHECK_AND_RETURN_RET_LOG(policyServer_ != nullptr, ERR_FOCUS_DENIED, "policyServer nullptr"); - policyServer_->ReloadLoudVolumeMode(streamType); -#endif if (AudioInterruptIsActiveInFocusList(zoneId, incomingStreamId) && !isUpdatedAudioStrategy) { AUDIO_INFO_LOG("Stream is active in focus list, no need to active audio interrupt."); return SUCCESS; diff --git a/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h b/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h index fdcea314e5b64ae7016ebb79d12bf168806c631d..0ca84aa05d885799a2eed2394a37d3dd4dc9024e 100644 --- a/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h +++ b/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h @@ -302,7 +302,7 @@ public: int32_t SetQueryDeviceVolumeBehaviorCallback(const sptr &object); void HandleDistributedDeviceVolume(); void SetSleVoiceStatusFlag(bool isSleVoiceStatus); - void SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state); + void SendLoudVolumeModeToDsp(LoudVolumeHoldType funcHoldType, bool state); void SaveSystemVolumeForEffect(DeviceType deviceType, AudioStreamType streamType, int32_t volumeLevel); int32_t GetSystemVolumeForEffect(DeviceType deviceType, AudioStreamType streamType); int32_t SetSystemVolumeToEffect(AudioStreamType streamType, float volume); diff --git a/services/audio_policy/server/domain/volume/include/audio_loud_volume_manager.h b/services/audio_policy/server/domain/volume/include/audio_loud_volume_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..ba84f15f6a2435a1bd9ca3d7dbab661a500832cf --- /dev/null +++ b/services/audio_policy/server/domain/volume/include/audio_loud_volume_manager.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_LOUD_VOLUME_MANAGER_H +#define AUDIO_LOUD_VOLUME_MANAGER_H + +#include +#include + +#include "audio_stream_info.h" +#include "iaudio_policy_interface.h" +#include "audio_active_device.h" +#include "audio_volume_manager.h" + + +namespace OHOS { +namespace AudioStandard { + +#ifdef FEATURE_MULTIMODALINPUT_INPUT +class LoudVolumeManager { +public: + explicit LoudVolumeManager(); + virtual ~LoudVolumeManager(); + bool loudVolumeModeEnable_ = false; + bool ReloadLoudVolumeMode(const AudioStreamType streamInFocus, SetLoudVolMode setVolMode); + bool ReloadLoudVolumeModeSwitch(LoudVolumeHoldType funcHoldType, SetLoudVolMode setVolMode); + void SetLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType, bool state); + bool ClearLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType); + bool GetLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType, bool &state); + bool CheckLoudVolumeMode(const int32_t volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); + bool IsSkipCloseLoudVolType(AudioStreamType streamType); + bool FindLoudVolStreamTypeEnable(AudioStreamType streamType, LoudVolumeHoldType &funcHoldType); +private: + AudioVolumeManager &audioVolumeManager_; + AudioActiveDevice &audioActiveDevice_; + int32_t triggerTime = 0; + int64_t upTriggerTimeMSec = 0; + std::mutex loudVolTrigTimeMutex_; + std::mutex setLoudVolHoldMutex_; + std::unordered_map loudVolumeHoldMap_; + const std::map LOUD_VOL_STREAM_TYPE_ENABLE = { + {STREAM_MUSIC, LOUD_VOLUME_MODE_MUSIC}, + {STREAM_VOICE_CALL, LOUD_VOLUME_MODE_VOICE}, + {STREAM_VOICE_CALL_ASSISTANT, LOUD_VOLUME_MODE_VOICE}, + }; + const std::map CONCURRENCY_KSIP_CLOSE_LOUD_VOL_TYPE = { + {STREAM_RING, STREAM_RING}, + }; +}; +#endif +} +} +#endif \ No newline at end of file diff --git a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h index bca4787666f7b470da3ba2443184d4c8e896839f..d7d6e1679baacd8bdcfae6f143e6c0d5d0298608 100644 --- a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h +++ b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h @@ -52,8 +52,8 @@ public: typedef AudioSafeVolumeNotification* CreateSafeVolumeNotification(); -const int32_t LOUD_ICON_WIDTH = 24; -const int32_t LOUD_ICON_HEIGHT = 24; +const int32_t LOUD_ICON_WIDTH = 120; +const int32_t LOUD_ICON_HEIGHT = 120; const std::string LOUD_VOLUME_ICON_ID = "loud_volume_notification_icon"; const std::string LOUD_VOLUME_FEATURE_TITTLE_ID = "notification_feature_loud_volume_tittle"; diff --git a/services/audio_policy/server/domain/volume/include/audio_volume_manager.h b/services/audio_policy/server/domain/volume/include/audio_volume_manager.h index 2ea2e3bcf80c34e4d5c299a86670b72b516b1625..302cdc30a0319c70a98f81edccfe1f3ef1d2b076 100644 --- a/services/audio_policy/server/domain/volume/include/audio_volume_manager.h +++ b/services/audio_policy/server/domain/volume/include/audio_volume_manager.h @@ -138,7 +138,7 @@ public: void OnTimerExpired(); bool IsNeedForceControlVolumeType(); AudioVolumeType GetForceControlVolumeType(); - void SendLoudVolumeMode(FunctionHoldType funcHoldType, bool state, bool repeatTrigNotif = false); + void SendLoudVolumeMode(LoudVolumeHoldType funcHoldType, bool state, bool repeatTrigNotif = false); private: AudioVolumeManager() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), diff --git a/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h b/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h index 8be01d59d314be1f5d5a362d3d469df19b2b4dfb..0f50e6eae4907157d24a22da84d2e2010f2f528b 100644 --- a/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h +++ b/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h @@ -32,6 +32,13 @@ namespace OHOS { namespace AudioStandard { + +enum LoudVolumeHoldType { + LOUD_VOLUME_MODE_INVALID = -1, + LOUD_VOLUME_MODE_MUSIC, + LOUD_VOLUME_MODE_VOICE, +}; + class IAudioPolicyInterface { public: virtual ~IAudioPolicyInterface() {} @@ -246,8 +253,7 @@ public: virtual int32_t SetQueryDeviceVolumeBehaviorCallback(const sptr &object) = 0; virtual void SetSleVoiceStatusFlag(bool isSleVoiceStatus) = 0; - virtual void SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state) = 0; - + virtual void SendLoudVolumeModeToDsp(LoudVolumeHoldType funcHoldType, bool state) = 0; virtual void SaveSystemVolumeForEffect(DeviceType deviceType, AudioStreamType streamType, int32_t volumeLevel) = 0; diff --git a/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp b/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp index f47ba066b50627634bdc7cede2ea439596538161..fd1faf6283af4296a64b75dd74da65bf40e6b5f6 100644 --- a/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp +++ b/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp @@ -414,19 +414,20 @@ void AudioAdapterManager::UpdateSafeVolumeByS4() SetVolumeDb(STREAM_MUSIC); } -void AudioAdapterManager::SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state) +void AudioAdapterManager::SendLoudVolumeModeToDsp(LoudVolumeHoldType funcHoldType, bool state) { std::string key = "LOUD_VOLUME_MODE"; std::string value = "super_loudness_mode=voice_off"; std::string identity = IPCSkeleton::ResetCallingIdentity(); CHECK_AND_RETURN_LOG(audioServerProxy_ != nullptr, "audioServerProxy_ null"); - if (FUNCTION_HOLD_SYSTEM == funcHoldType) { + if (LOUD_VOLUME_MODE_VOICE == funcHoldType) { value = state ? "super_loudness_mode=voice_on" : "super_loudness_mode=voice_off"; - } else if (FUNCTION_HOLD_MUSIC == funcHoldType) { + } else if (LOUD_VOLUME_MODE_MUSIC == funcHoldType) { value = state ? "super_loudness_mode=music_on" : "super_loudness_mode=music_off"; } else { AUDIO_ERR_LOG("funcHoldType error : %{public}d", funcHoldType); + IPCSkeleton::SetCallingIdentity(identity); return; } diff --git a/services/audio_policy/server/domain/volume/src/audio_loud_volume_manager.cpp b/services/audio_policy/server/domain/volume/src/audio_loud_volume_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7c132ae917ba4f66fe583c52ba8b5e3b22bbc045 --- /dev/null +++ b/services/audio_policy/server/domain/volume/src/audio_loud_volume_manager.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef LOG_TAG +#define LOG_TAG "AudioLoudVolumeManager" +#endif + +#include "audio_loud_volume_manager.h" + +#ifdef FEATURE_MULTIMODALINPUT_INPUT +#include "input_manager.h" +#endif +#include "parameters.h" +using namespace std; +namespace OHOS { +namespace AudioStandard { + +#ifdef FEATURE_MULTIMODALINPUT_INPUT +LoudVolumeManager::LoudVolumeManager() + : audioVolumeManager_(AudioVolumeManager::GetInstance()), + audioActiveDevice_(AudioActiveDevice::GetInstance()) + +{ + loudVolumeModeEnable_ = system::GetBoolParameter("const.audio.loudvolume", false); + AUDIO_INFO_LOG("create LoudVolumeManager"); +}; + +LoudVolumeManager::~LoudVolumeManager() +{ + AUDIO_WARNING_LOG("dtor should not happen"); +}; + +bool LoudVolumeManager::IsSkipCloseLoudVolType(AudioStreamType streamType) +{ + auto iter = CONCURRENCY_KSIP_CLOSE_LOUD_VOL_TYPE.find(VolumeUtils::GetVolumeTypeFromStreamType(streamType)); + if (iter != CONCURRENCY_KSIP_CLOSE_LOUD_VOL_TYPE.end()) { + return true; + } + return false; +} + +bool LoudVolumeManager::FindLoudVolStreamTypeEnable( + AudioStreamType streamType, LoudVolumeHoldType &funcHoldType) +{ + auto iter = LOUD_VOL_STREAM_TYPE_ENABLE.find(VolumeUtils::GetVolumeTypeFromStreamType(streamType)); + if (iter != LOUD_VOL_STREAM_TYPE_ENABLE.end()) { + funcHoldType = iter->second; + return true; + } + return false; +} + +void LoudVolumeManager::SetLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType, bool state) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + loudVolumeHoldMap_[funcHoldType] = state; +} + +bool LoudVolumeManager::ClearLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + auto it = loudVolumeHoldMap_.find(funcHoldType); + if (it != loudVolumeHoldMap_.end()) { + loudVolumeHoldMap_.erase(it); + return true; + } + return false; +} + +bool LoudVolumeManager::GetLoudVolumeHoldMap(LoudVolumeHoldType funcHoldType, bool &state) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + if (loudVolumeHoldMap_.count(funcHoldType) > 0) { + state = loudVolumeHoldMap_[funcHoldType]; + return true; + } + return false; +} + +bool LoudVolumeManager::ReloadLoudVolumeModeSwitch(LoudVolumeHoldType funcHoldType, SetLoudVolMode setVolMode) +{ + bool isHolding = false; + bool isInLoudVolumeMode = GetLoudVolumeHoldMap(funcHoldType, isHolding); + switch (setVolMode) { + case LOUD_VOLUME_SWITCH_ON: + if (!isInLoudVolumeMode) { + if (funcHoldType == LOUD_VOLUME_MODE_MUSIC) { + SetLoudVolumeHoldMap(funcHoldType, true); + } else { + SetLoudVolumeHoldMap(funcHoldType, false); + } + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true, true); + } + break; + case LOUD_VOLUME_SWITCH_OFF: + if (isInLoudVolumeMode) { + ClearLoudVolumeHoldMap(funcHoldType); + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, false); + } + break; + case LOUD_VOLUME_SWITCH_PAUSE: + if (isInLoudVolumeMode) { + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, false); + } + break; + case LOUD_VOLUME_SWITCH_AUTO: + if (isInLoudVolumeMode && isHolding) { + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true); + } else { + AUDIO_INFO_LOG("no need load loud volume mode"); + } + break; + default: + AUDIO_ERR_LOG("setVolMode error : %{public}d", setVolMode); + return false; + } + + return true; +} + +bool LoudVolumeManager::ReloadLoudVolumeMode( + const AudioStreamType streamInFocus, SetLoudVolMode setVolMode) +{ + if (!loudVolumeModeEnable_) { + return false; + } + LoudVolumeHoldType funcHoldType = LOUD_VOLUME_MODE_INVALID; + if (IsSkipCloseLoudVolType(streamInFocus)) { + AUDIO_INFO_LOG("streamType = %{public}d, skip operation loud volume mode.", streamInFocus); + return false; + } + if (!FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType) || + audioActiveDevice_.GetCurrentOutputDeviceNetworkId() != LOCAL_NETWORK_ID || + audioActiveDevice_.GetCurrentOutputDeviceType() != DeviceType::DEVICE_TYPE_SPEAKER) { + AUDIO_INFO_LOG("streamType = %{public}d, or deviceType = %{public}d not support loud volume mode.", + streamInFocus, audioActiveDevice_.GetCurrentOutputDeviceType()); + return false; + } + + return ReloadLoudVolumeModeSwitch(funcHoldType, setVolMode); +} + +bool LoudVolumeManager::CheckLoudVolumeMode(const int32_t volLevel, + const int32_t keyType, const AudioStreamType &streamInFocus) +{ + LoudVolumeHoldType funcHoldType = LOUD_VOLUME_MODE_INVALID; + if (!loudVolumeModeEnable_ || !FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType)) { + return false; + } + std::lock_guard lock(loudVolTrigTimeMutex_); + constexpr int32_t MAX_TRIGGER_TIMES = 2; + constexpr int32_t ENABLE_TRIGGER_TIMES = 1; + constexpr int32_t MAX_LOUD_VOLUME_MSEC = 3000; + constexpr int32_t MIN_LOUD_VOLUME_MSEC = 400; + bool isHolding = false; + + struct timeval tv; + struct timezone tz; + gettimeofday(&tv, &tz); + int64_t mSec = static_cast(tv.tv_sec * 1000 + tv.tv_usec / AUDIO_MS_PER_SECOND); + + int32_t volumeLevelMax = audioVolumeManager_.GetMaxVolumeLevel(streamInFocus); + int32_t volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? volLevel + 1 : volLevel - 1; + if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP && (volumeLevelInInt >= volumeLevelMax)) { + if (GetLoudVolumeHoldMap(funcHoldType, isHolding)) { + AUDIO_DEBUG_LOG("no need to repeatedly set loud volume mode."); + return false; + } + if (triggerTime == MAX_TRIGGER_TIMES && mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) { + triggerTime = 0; + bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_ON); + CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume on error"); + return true; + } else if (triggerTime == ENABLE_TRIGGER_TIMES && (mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) && + (mSec - upTriggerTimeMSec > MIN_LOUD_VOLUME_MSEC)) { + triggerTime++; + } else { + triggerTime = ENABLE_TRIGGER_TIMES; + } + upTriggerTimeMSec = mSec; + } else if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN && GetLoudVolumeHoldMap(funcHoldType, isHolding)) { + upTriggerTimeMSec = mSec; + triggerTime = ENABLE_TRIGGER_TIMES; + bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_OFF); + CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume off error"); + return true; + } else { + upTriggerTimeMSec = 0; + triggerTime = 0; + } + return false; +} +#endif +} +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp b/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp index 71cd9961b62637f3c4164e549610eb66611cd49e..14f4a9c978fb11561cd2968e9394526956b86ee1 100644 --- a/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp +++ b/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp @@ -347,7 +347,7 @@ void AudioVolumeManager::PublishLoudVolumeNotification(int32_t notificationId) #endif } -void AudioVolumeManager::SendLoudVolumeMode(FunctionHoldType funcHoldType, bool state, bool repeatTrigNotif) +void AudioVolumeManager::SendLoudVolumeMode(LoudVolumeHoldType funcHoldType, bool state, bool repeatTrigNotif) { if (state && repeatTrigNotif) { const int INSTANT_NOTIFICATION_ID = 6; diff --git a/services/audio_policy/server/service/service_main/include/audio_policy_server.h b/services/audio_policy/server/service/service_main/include/audio_policy_server.h index acb0f7cfbcdfdf88da59d925a266bc34908b5572..41631218e5c5e61ca4a6c6aa8cdcc8233bf84e46 100644 --- a/services/audio_policy/server/service/service_main/include/audio_policy_server.h +++ b/services/audio_policy/server/service/service_main/include/audio_policy_server.h @@ -50,7 +50,9 @@ #include "app_state_listener.h" #include "audio_core_service.h" #include "audio_converter_parser.h" - +#ifdef FEATURE_MULTIMODALINPUT_INPUT +#include "audio_loud_volume_manager.h" +#endif #ifdef USB_ENABLE #include "audio_usb_manager.h" #endif @@ -697,10 +699,8 @@ public: int32_t UpdateDeviceInfo(const std::shared_ptr &deviceDesc, int32_t command) override; int32_t SetSleAudioOperationCallback(const sptr &object) override; int32_t CallRingtoneLibrary(); -#ifdef FEATURE_MULTIMODALINPUT_INPUT - bool ReloadLoudVolumeMode(const AudioStreamType streamInFocus, - SetLoudVolMode setVolMode = LOUD_VOLUME_SWITCH_UNSET); -#endif + int32_t ReloadLoudVolumeMode(const int32_t streamInFocus, const int32_t setVolMode, bool &ret) override; + bool CheckLoudVolumeMode(bool mute, int32_t volumeLevel, AudioStreamType streamType); protected: void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; void RegisterParamCallback(); @@ -738,6 +738,7 @@ private: AudioPolicyServer *policyServer_; }; + void Init(); int32_t VerifyVoiceCallPermission(uint64_t fullTokenId, Security::AccessToken::AccessTokenID tokenId); // offload session @@ -791,10 +792,7 @@ private: bool IsContinueAddVol(); void TriggerMuteCheck(); int32_t ProcessVolumeKeyEvents(const int32_t keyType); - void SetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool state); - bool ClearLoudVolumeHoldMap(FunctionHoldType funcHoldType); - bool GetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool &state); - bool CheckLoudVolumeMode(const int32_t volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); + std::shared_ptr loudVolumeManager_; #endif void AddAudioServiceOnStart(); void SubscribeOsAccountChangeEvents(); @@ -883,13 +881,6 @@ private: std::mutex volUpHistoryMutex_; std::deque volUpHistory_; std::atomic hasSubscribedVolumeKeyEvents_ = false; - - int32_t triggerTime = 0; - int64_t upTriggerTimeMSec = 0; - std::mutex loudVolTrigTimeMutex_; - AudioStreamType lastReloadStreamType = STREAM_DEFAULT; - std::mutex setLoudVolHoldMutex_; - std::unordered_map loudVolumeHoldMap_; #endif std::vector clientDiedListenerState_; sptr powerStateListener_; @@ -907,8 +898,9 @@ private: bool volumeApplyToAll_ = false; bool screenOffAdjustVolumeEnable_ = false; bool supportVibrator_ = false; +#ifdef FEATURE_MULTIMODALINPUT_INPUT bool loudVolumeModeEnable_ = false; - +#endif bool isHighResolutionExist_ = false; std::mutex descLock_; diff --git a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp index 9e98bd9f0c9eeef4eec08a91b7140b29d1913a35..5f537106e285f1937405f42017870d5a91502895 100644 --- a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp @@ -171,7 +171,9 @@ AudioPolicyServer::AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate) supportVibrator_ = system::GetBoolParameter("const.vibrator.support_vibrator", true); volumeApplyToAll_ = system::GetBoolParameter("const.audio.volume_apply_to_all", false); screenOffAdjustVolumeEnable_ = system::GetBoolParameter("const.audio.screenoff_adjust_volume_enable", false); +#ifdef FEATURE_MULTIMODALINPUT_INPUT loudVolumeModeEnable_ = system::GetBoolParameter("const.audio.loudvolume", false); +#endif if (volumeApplyToAll_) { audioPolicyConfigManager_.SetNormalVoipFlag(true); } @@ -229,10 +231,17 @@ void AudioPolicyServer::OnDump() return; } -void AudioPolicyServer::OnStart() +void AudioPolicyServer::Init() { - AUDIO_INFO_LOG("Audio policy server on start"); - DlopenUtils::Init(); +#ifdef FEATURE_MULTIMODALINPUT_INPUT + if (loudVolumeModeEnable_) { + loudVolumeManager_ = std::make_shared(); + if (loudVolumeManager_ == nullptr) { + AUDIO_ERR_LOG("loudVolumeManager_ is nullptr"); + return; + } + } +#endif interruptService_ = std::make_shared(); interruptService_->Init(this); @@ -252,6 +261,13 @@ void AudioPolicyServer::OnStart() coreService_->SetCallbackHandler(audioPolicyServerHandler_); coreService_->Init(); eventEntry_ = coreService_->GetEventEntry(); +} + +void AudioPolicyServer::OnStart() +{ + AUDIO_INFO_LOG("Audio policy server on start"); + DlopenUtils::Init(); + Init(); bool res = Publish(this); if (!res) { @@ -432,160 +448,50 @@ bool AudioPolicyServer::MaxOrMinVolumeOption(const int32_t &volLevel, const int3 } #endif -#ifdef FEATURE_MULTIMODALINPUT_INPUT -const std::map LOUD_VOL_STREAM_TYPE_ENABLE = { - {STREAM_VOICE_CALL, FUNCTION_HOLD_SYSTEM}, - {STREAM_MUSIC, FUNCTION_HOLD_MUSIC}, - {STREAM_MEDIA, FUNCTION_HOLD_MUSIC}, - {STREAM_MOVIE, FUNCTION_HOLD_MUSIC}, - {STREAM_GAME, FUNCTION_HOLD_MUSIC}, - {STREAM_SPEECH, FUNCTION_HOLD_MUSIC}, - {STREAM_VOICE_MESSAGE, FUNCTION_HOLD_MUSIC}, - {STREAM_NAVIGATION, FUNCTION_HOLD_MUSIC}, - {STREAM_SOURCE_VOICE_CALL, FUNCTION_HOLD_SYSTEM}, - {STREAM_VOICE_COMMUNICATION, FUNCTION_HOLD_SYSTEM}, -}; - -bool FindLoudVolStreamTypeEnable(AudioStreamType streamType, FunctionHoldType &funcHoldType) -{ - auto iter = LOUD_VOL_STREAM_TYPE_ENABLE.find(streamType); - if (iter != LOUD_VOL_STREAM_TYPE_ENABLE.end()) { - funcHoldType = iter->second; - return true; - } - return false; -} - -void AudioPolicyServer::SetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool state) -{ - std::lock_guard lock(setLoudVolHoldMutex_); - loudVolumeHoldMap_[funcHoldType] = state; -} - -bool AudioPolicyServer::ClearLoudVolumeHoldMap(FunctionHoldType funcHoldType) -{ - std::lock_guard lock(setLoudVolHoldMutex_); - auto it = loudVolumeHoldMap_.find(funcHoldType); - if (it != loudVolumeHoldMap_.end()) { - loudVolumeHoldMap_.erase(it); - return true; - } - return false; -} - -bool AudioPolicyServer::GetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool &state) -{ - std::lock_guard lock(setLoudVolHoldMutex_); - if (loudVolumeHoldMap_.count(funcHoldType) > 0) { - state = loudVolumeHoldMap_[funcHoldType]; - return true; - } - return false; -} - -bool AudioPolicyServer::ReloadLoudVolumeMode(const AudioStreamType streamInFocus, SetLoudVolMode setVolMode) +int32_t AudioPolicyServer::ReloadLoudVolumeMode( + int32_t streamInFocus, int32_t setVolMode, bool &ret) { +#ifdef FEATURE_MULTIMODALINPUT_INPUT if (!loudVolumeModeEnable_) { - return false; - } - FunctionHoldType funcHoldType = FUNCTION_HOLD_INVALID; - if (false == FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType) || - (audioActiveDevice_.GetCurrentOutputDeviceType() != DeviceType::DEVICE_TYPE_SPEAKER)) { - audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_MUSIC, false); - audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_SYSTEM, false); - AUDIO_INFO_LOG("streamType = %{public}d, or deviceType = %{public}d not support loud volume mode.", - streamInFocus, audioActiveDevice_.GetCurrentOutputDeviceType()); - return false; + ret = false; + return AUDIO_INVALID_PARAM; } - if (lastReloadStreamType != streamInFocus) { - if (FUNCTION_HOLD_SYSTEM == funcHoldType) { - audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_MUSIC, false); - } else if (FUNCTION_HOLD_MUSIC == funcHoldType) { - audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_SYSTEM, false); - ClearLoudVolumeHoldMap(FUNCTION_HOLD_SYSTEM); - } + if (loudVolumeManager_ == nullptr) { + AUDIO_INFO_LOG("loudVolumeManager_ is nullptr!"); + ret = false; + return AUDIO_INVALID_PARAM; } - - if (setVolMode == LOUD_VOLUME_SWITCH_ON) { - if (FUNCTION_HOLD_MUSIC == funcHoldType) { - SetLoudVolumeHoldMap(funcHoldType, true); - } else if (FUNCTION_HOLD_SYSTEM == funcHoldType) { - SetLoudVolumeHoldMap(funcHoldType, false); - } - audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true, true); - } else if (setVolMode == LOUD_VOLUME_SWITCH_OFF) { - ClearLoudVolumeHoldMap(funcHoldType); - audioVolumeManager_.SendLoudVolumeMode(funcHoldType, false); - } else if (setVolMode == LOUD_VOLUME_SWITCH_UNSET) { - bool isHolding = false; - bool ret = GetLoudVolumeHoldMap(funcHoldType, isHolding); - if (ret && isHolding) { - audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true); - } else { - AUDIO_INFO_LOG("no need load loud volume mode"); + if (loudVolumeManager_->ReloadLoudVolumeMode(static_cast(streamInFocus), + static_cast(setVolMode)) == true) { + ret = true; + return AUDIO_OK; } - } else { - AUDIO_ERR_LOG("setVolMode error : %{public}d", setVolMode); - return false; - } - - return true; +#endif + ret = false; + return AUDIO_INVALID_PARAM; } -bool AudioPolicyServer::CheckLoudVolumeMode(const int32_t volLevel, - const int32_t keyType, const AudioStreamType &streamInFocus) +bool AudioPolicyServer::CheckLoudVolumeMode(bool mute, int32_t volumeLevel, AudioStreamType streamType) { - std::lock_guard lock(loudVolTrigTimeMutex_); - constexpr int32_t MAX_TRIGGER_TIMES = 2; - constexpr int32_t ENABLE_TRIGGER_TIMES = 1; - constexpr int32_t MAX_LOUD_VOLUME_MSEC = 3000; - constexpr int32_t MIN_LOUD_VOLUME_MSEC = 400; - bool isHolding = false; - FunctionHoldType funcHoldType = FUNCTION_HOLD_INVALID; - if (!loudVolumeModeEnable_ && !FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType)) { +#ifdef FEATURE_MULTIMODALINPUT_INPUT + if (!loudVolumeModeEnable_ || loudVolumeManager_ == nullptr) { return false; } - - struct timeval tv; - struct timezone tz; - gettimeofday(&tv, &tz); - int64_t mSec = static_cast(tv.tv_sec * 1000 + tv.tv_usec / AUDIO_MS_PER_SECOND); - int32_t volumeLevelMax = -1; - int32_t streamInFocusInt = static_cast(streamInFocus); - GetMaxVolumeLevel(streamInFocusInt, volumeLevelMax); - int32_t volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? volLevel + 1 : volLevel - 1; - if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP && (volumeLevelInInt >= volumeLevelMax)) { - if (GetLoudVolumeHoldMap(funcHoldType, isHolding)) { - AUDIO_DEBUG_LOG("no need to repeatedly set loud volume mode."); - return false; - } - if (triggerTime == MAX_TRIGGER_TIMES && mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) { - triggerTime = 0; - bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_ON); - CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume on error"); - lastReloadStreamType = streamInFocus; - return true; - } else if (triggerTime == ENABLE_TRIGGER_TIMES && (mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) && - (mSec - upTriggerTimeMSec > MIN_LOUD_VOLUME_MSEC)) { - triggerTime++; - } else { - triggerTime = ENABLE_TRIGGER_TIMES; - } - upTriggerTimeMSec = mSec; - } else if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN && GetLoudVolumeHoldMap(funcHoldType, isHolding)) { - upTriggerTimeMSec = mSec; - triggerTime = ENABLE_TRIGGER_TIMES; - bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_OFF); - CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume off error"); + GetMaxVolumeLevel(static_cast(streamType), volumeLevelMax); + int32_t deviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); + + int32_t keyCode = (volumeLevelMax > volumeLevel) ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN + : OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; + keyCode = mute ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN : keyCode; + if (loudVolumeManager_->CheckLoudVolumeMode(volumeLevel, keyCode, streamType)) { + AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", + deviceType, streamType); return true; - } else { - upTriggerTimeMSec = 0; - triggerTime = 0; } +#endif return false; } -#endif void AudioPolicyServer::ChangeVolumeOnVoiceAssistant(AudioStreamType &streamInFocus) { @@ -742,23 +648,28 @@ int32_t AudioPolicyServer::ProcessVolumeKeyEvents(const int32_t keyType) int32_t AudioPolicyServer::SetVolumeInternalByKeyEvent(AudioStreamType streamInFocus, int32_t zoneId, const int32_t keyType) { - bool updateVol = true; int32_t volumeLevelInInt = GetSystemVolumeLevelInternal(streamInFocus, zoneId); - if (audioActiveDevice_.GetCurrentOutputDeviceType() == DeviceType::DEVICE_TYPE_SPEAKER && - CheckLoudVolumeMode(volumeLevelInInt, keyType, streamInFocus)) { - updateVol = false; - AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", - audioActiveDevice_.GetCurrentOutputDeviceType(), streamInFocus); - } else if (MaxOrMinVolumeOption(volumeLevelInInt, keyType, streamInFocus)) { +#ifdef FEATURE_MULTIMODALINPUT_INPUT + if (loudVolumeModeEnable_) { + if (loudVolumeManager_ == nullptr) { + AUDIO_ERR_LOG("loudVolumeManager_ is nullptr!"); + } else if (loudVolumeManager_->CheckLoudVolumeMode(volumeLevelInInt, keyType, streamInFocus)) { + SendVolumeKeyEventCbWithUpdateUiOrNot(streamInFocus, true); + AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", + audioActiveDevice_.GetCurrentOutputDeviceType(), streamInFocus); + return AUDIO_OK; + } + } +#endif + if (MaxOrMinVolumeOption(volumeLevelInInt, keyType, streamInFocus)) { AUDIO_ERR_LOG("device %{public}d, stream %{public}d, volumelevel %{public}d invalid", audioActiveDevice_.GetCurrentOutputDeviceType(), streamInFocus, volumeLevelInInt); return ERROR_INVALID_PARAM; } - if (updateVol) { - volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) - ? ++volumeLevelInInt : --volumeLevelInInt; - } + volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? ++volumeLevelInInt : + --volumeLevelInInt; + int32_t ret = SetSystemVolumeLevelInternal(streamInFocus, volumeLevelInInt, true, zoneId); if (ret == ERR_SET_VOL_FAILED_BY_VOLUME_CONTROL_DISABLED) { SendVolumeKeyEventCbWithUpdateUiOrNot(streamInFocus, true); @@ -1697,18 +1608,11 @@ int32_t AudioPolicyServer::SetSystemVolumeLevelInternal(AudioStreamType streamTy return ERR_OPERATION_FAILED; } bool mute = GetStreamMuteInternal(streamType, zoneId); - int32_t volumeLevelMax = -1; - GetMaxVolumeLevel(static_cast(streamType), volumeLevelMax); - int32_t deviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); - if (loudVolumeModeEnable_ && (mute || (isUpdateUi == false && deviceType == DeviceType::DEVICE_TYPE_SPEAKER))) { - int32_t keyCode = (volumeLevelMax > volumeLevel) ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN - : OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; - keyCode = mute ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN : keyCode; - if (CheckLoudVolumeMode(volumeLevel, keyCode, streamType)) { - AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", - deviceType, streamType); - } +#ifdef FEATURE_MULTIMODALINPUT_INPUT + if (loudVolumeModeEnable_ && !isUpdateUi) { + CheckLoudVolumeMode(mute, volumeLevel, streamType); } +#endif if (streamType == STREAM_ALL) { for (auto audioStreamType : GET_STREAM_ALL_VOLUME_TYPES) { AUDIO_INFO_LOG("SetVolume of STREAM_ALL, SteamType = %{public}d, mute = %{public}d, level = %{public}d", @@ -1735,17 +1639,6 @@ int32_t AudioPolicyServer::SetSystemVolumeLevelWithDeviceInternal(AudioStreamTyp AUDIO_ERR_LOG("Unadjustable device, not allow set volume"); return ERR_OPERATION_FAILED; } - - int32_t volumeLevelMax = -1; - GetMaxVolumeLevel(static_cast(streamType), volumeLevelMax); - if (loudVolumeModeEnable_ && isUpdateUi == false && deviceType == DeviceType::DEVICE_TYPE_SPEAKER) { - int32_t keyCode = (volumeLevelMax > volumeLevel) ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN - : OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; - if (CheckLoudVolumeMode(volumeLevel, keyCode, streamType)) { - AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", - deviceType, streamType); - } - } return SetSingleStreamVolumeWithDevice(streamType, volumeLevel, isUpdateUi, deviceType); } diff --git a/services/audio_service/client/include/renderer_in_client_private.h b/services/audio_service/client/include/renderer_in_client_private.h index e847917ac8e8f2ed8ac1a2eaa7bb8939e379fb76..060b9f990114d5b2c1ee6d17846a7ce2b2e1ce5e 100644 --- a/services/audio_service/client/include/renderer_in_client_private.h +++ b/services/audio_service/client/include/renderer_in_client_private.h @@ -463,6 +463,8 @@ private: bool isUpEvent_ = false; std::shared_ptr proxyObj_ = nullptr; int64_t preWriteEndTime_ = 0; + bool loudVolumeModeEnable_ = false; + uint64_t lastFlushReadIndex_ = 0; uint64_t lastSpeedFlushReadIndex_ = 0; bool isDataLinkConnected_ = false; diff --git a/services/audio_service/client/src/renderer_in_client_public.cpp b/services/audio_service/client/src/renderer_in_client_public.cpp index a25ba3773fab079e3023678b7d93fe7590aed4bf..88123de3dbd027ef2d062178f43e3592ec6367a6 100644 --- a/services/audio_service/client/src/renderer_in_client_public.cpp +++ b/services/audio_service/client/src/renderer_in_client_public.cpp @@ -56,6 +56,7 @@ #include "audio_effect_map.h" #include "media_monitor_manager.h" +#include "parameters.h" using namespace OHOS::HiviewDFX; using namespace OHOS::AppExecFwk; @@ -85,6 +86,7 @@ RendererInClientInner::RendererInClientInner(AudioStreamType eStreamType, int32_ { AUDIO_INFO_LOG("Create with StreamType:%{public}d appUid:%{public}d ", eStreamType_, appUid_); audioStreamTracker_ = std::make_unique(AUDIO_MODE_PLAYBACK, appUid); + loudVolumeModeEnable_ = OHOS::system::GetBoolParameter("const.audio.loudvolume", false); state_ = NEW; } @@ -996,8 +998,12 @@ bool RendererInClientInner::StartAudioStream(StateChangeCmdType cmdType, } waitLock.unlock(); + if (loudVolumeModeEnable_) { + AudioPolicyManager::GetInstance().ReloadLoudVolumeMode(eStreamType_, LOUD_VOLUME_SWITCH_AUTO); + } HILOG_COMM_INFO("Start SUCCESS, sessionId: %{public}d, uid: %{public}d", sessionId_, clientUid_); + UpdateTracker("RUNNING"); FlushBeforeStart();