diff --git a/bundle.json b/bundle.json index bcdddf9e18c4acb395ba428d597c439c807f2839..a718e652f8fde2c6f30bae46a723310876e65881 100644 --- a/bundle.json +++ b/bundle.json @@ -74,8 +74,7 @@ "device_manager", "openssl", "libphonenumber", - "screenlock_mgr", - "user_status_awareness" + "screenlock_mgr" ], "third_party": [ "libphonenumber", diff --git a/callmanager.gni b/callmanager.gni index c17ec216233d1093b31ffd4047ff25c4e91930a5..7bfa87b06bc7a3f8717ed8a8b16aa2388d486849 100644 --- a/callmanager.gni +++ b/callmanager.gni @@ -312,7 +312,6 @@ if (defined(global_parts_info) && defined(global_parts_info.msdp_motion) && if (defined(global_parts_info) && defined(global_parts_info.msdp_user_status_awareness) && global_parts_info.msdp_user_status_awareness) { - call_manager_external_deps += [ "user_status_awareness:user_status_client" ] call_manager_defines += [ "OHOS_SUBSCRIBE_USER_STATUS_ENABLE" ] } diff --git a/services/audio/include/audio_control_manager.h b/services/audio/include/audio_control_manager.h index 20e85480195f60592de8c149a012636eeab7dd26..0d488b9bd5dbc9c7a39efbc98191f577b7bdfaba 100644 --- a/services/audio/include/audio_control_manager.h +++ b/services/audio/include/audio_control_manager.h @@ -154,6 +154,7 @@ private: ffrt::mutex crsMutex_{}; std::unique_ptr audioRenderer_ = nullptr; ffrt::mutex audioRendererMutex_{}; + ffrt::recursive_mutex ringMutex_{}; bool isPlayForNoRing_ = false; }; } // namespace Telephony diff --git a/services/audio/include/msdp_manager.h b/services/audio/include/msdp_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..795fbe6803247493e9df5f58f2e436e7526375f7 --- /dev/null +++ b/services/audio/include/msdp_manager.h @@ -0,0 +1,127 @@ +/* + * Copyright (C) 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 MSDP_MANAGER_H +#define MSDP_MANAGER_H + +#include +#include +#include +#include +#include +#include "nocopyable.h" +#include "string_ex.h" +#include "parcel.h" + +namespace OHOS { +namespace Telephony { +class UserStatusData : public Parcelable { +public: + UserStatusData(); + virtual ~UserStatusData(); + + uint32_t GetFeature() const; + void SetFeature(uint32_t feature); + + std::string GetStatus() const; + void SetStatus(const std::string &status); + + int32_t GetResult() const; + void SetResult(int32_t result); + + int32_t GetErrorCode() const; + void SetErrorCode(int32_t errorCode); + + std::vector GetResultApps() const; + void SetResultApps(const std::vector& resultApps); + + std::string GetHpeDeviceId() const; + void SetHpeDeviceId(const std::string &hpeDeviceId); + + int32_t GetCoordinateX() const; + void SetCoordinateX(int32_t coordinateX); + + int32_t GetCoordinateY() const; + void SetCoordinateY(int32_t coordinateY); + + int32_t GetPointerAction() const; + void SetPointerAction(int32_t pointerAction); + + int32_t GetOrientation() const; + void SetOrientation(int32_t orientation); + + virtual std::string Dump(); + virtual std::shared_ptr Unmarshalling(Parcel &parcel); + static int32_t UnMarshallingFeature(Parcel &parcel); + bool Marshalling(Parcel &parcel) const override; + bool WriteTimeTunnelData(Parcel &parcel) const; + +protected: + std::string DumpBaseData(); + uint32_t feature_ { 0 }; + int32_t result_ { 0 }; + int32_t errorCode_ { 0 }; + std::string status_; + int32_t coordinateX_ { 0 }; + int32_t coordinateY_ { 0 }; + int32_t pointerAction_ { 0 }; + int32_t orientation_ { 0 }; + virtual bool ReadFromParcel(Parcel &parcel); + +private: + std::vector resultApps_; + std::string hpeDeviceId_; +}; + +class ComfortReminderData : public UserStatusData { +public: + ComfortReminderData(); + ~ComfortReminderData(); + + int32_t GetFusionReminderData() const + { + return fusionReminderData_; + } + void SetFusionReminderData(const int32_t fusionReminderData); + + int32_t GetSwingReminderData() const; + void SetSwingReminderData(const int32_t swingReminderData); + + int32_t GetEventType() const + { + return eventType_; + } + void SetEventType(const int32_t eventType); + + std::string Dump() override; + std::shared_ptr Unmarshalling(Parcel &parcel) override; + + bool Marshalling(Parcel &parcel) const override; + +protected: + bool ReadFromParcel(Parcel &parcel) override; + +private: + bool MarshallComfortReminderData(Parcel &parcel) const; + + int32_t fusionReminderData_ { -1 }; + int32_t swingReminderData_ { -1 }; + int32_t eventType_ { -1 }; +}; + +using UserStatusDataCallbackFunc = std::function)>; +} // namespace Telephony +} // namespace OHOS +#endif // MSDP_MANAGER_H \ No newline at end of file diff --git a/services/audio/include/ring.h b/services/audio/include/ring.h index c80874f0439c4e9e08ed6339a2e9d93712cc7624..6c40c5cafa9d45ee8f60e0f9548f333dbe5164ec 100644 --- a/services/audio/include/ring.h +++ b/services/audio/include/ring.h @@ -28,10 +28,9 @@ #ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE #include "data_ability_observer_stub.h" -#include "comfort_reminder_data.h" #include "settings_datashare_helper.h" #include "datashare_helper.h" -#include "user_status_client.h" +#include "msdp_manager.h" #endif namespace OHOS { @@ -75,8 +74,7 @@ public: #ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE private: void GetSettingsData(); - void OnComfortReminderDataChanged(int32_t result, - std::shared_ptr comfortReminderData); + void OnComfortReminderDataChanged(int32_t result, std::shared_ptr comfortReminderData); int32_t RegisterUserStatusDataCallbackFunc(); int32_t SubscribeFeature(); int32_t UnsubscribeFeature(); @@ -111,6 +109,7 @@ private: std::atomic isFadeupHappend_{false}; std::atomic curRingVolLevel_{0}; sptr ringtoneSettingStatusObserver_ = nullptr; + void* userHandle_ = nullptr; #endif }; } // namespace Telephony diff --git a/services/audio/src/audio_control_manager.cpp b/services/audio/src/audio_control_manager.cpp index 6d67acd99abb9e32db706b0dd3c60dbbc9e40ad9..dd2d666b31ceecb9f3a2e28cc22226d7fccd5362 100644 --- a/services/audio/src/audio_control_manager.cpp +++ b/services/audio/src/audio_control_manager.cpp @@ -59,14 +59,14 @@ void AudioControlManager::Init() { DelayedSingleton::GetInstance()->Init(); DelayedSingleton::GetInstance()->Init(); + std::lock_guard lock(ringMutex_); ring_ = std::make_shared(); - if (ring_ == nullptr) { - TELEPHONY_LOGE("create ring object failed"); - return; - } - #ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE - ring_->RegisterObserver(); + if (ring_ != nullptr) { + ring_->RegisterObserver(); + } else { + TELEPHONY_LOGE("ring_ is nullptr ignore RegisterObserver"); + } #endif } @@ -76,7 +76,12 @@ void AudioControlManager::UnInit() DelayedSingleton::GetInstance()->UnsetAudioPreferDeviceChangeCallback(); DelayedSingleton::GetInstance()->UnsetAudioMicStateChangeCallback(); #ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE - ring_->UnRegisterObserver(); + std::lock_guard lock(ringMutex_); + if (ring_ != nullptr) { + ring_->UnRegisterObserver(); + } else { + TELEPHONY_LOGE("ring_ is nullptr ignore UnRegisterObserver"); + } #endif } @@ -808,6 +813,7 @@ bool AudioControlManager::PlayRingtone() } return true; } + std::lock_guard lock(ringMutex_); if (incomingCall->GetCallType() == CallType::TYPE_BLUETOOTH) { ret = ring_->Play(info.accountId, contactInfo.ringtonePath, Media::HapticStartupMode::FAST); } else { @@ -950,6 +956,7 @@ bool AudioControlManager::StopSoundtone() bool AudioControlManager::StopRingtone() { + std::lock_guard lock(ringMutex_); if (isPlayForNoRing_) { return StopForNoRing(); } @@ -1112,6 +1119,7 @@ int32_t AudioControlManager::MuteRinger() } return TELEPHONY_SUCCESS; } + std::lock_guard lock(ringMutex_); if (ring_ == nullptr) { TELEPHONY_LOGE("ring is nullptr"); return CALL_ERR_AUDIO_SETTING_MUTE_FAILED; @@ -1492,6 +1500,7 @@ bool AudioControlManager::IsBtCallDisconnected() void AudioControlManager::SetRingToneVolume(float volume) { + std::lock_guard lock(ringMutex_); if (ring_ == nullptr) { TELEPHONY_LOGE("ring_ is nullptr ignore SetRingToneVolume"); return; diff --git a/services/audio/src/ring.cpp b/services/audio/src/ring.cpp index 2d924e3492892c38ad941b720ed1faa272b4b9f9..4c47134c951d2c564d0bc0318550644298229643 100644 --- a/services/audio/src/ring.cpp +++ b/services/audio/src/ring.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "audio_player.h" #include "call_base.h" #include "telephony_log_wrapper.h" @@ -37,6 +38,14 @@ constexpr int32_t ONE_SECOND_US = 1000000; //us constexpr int32_t US_TO_MS = 1000; constexpr uint32_t FEATURE_COMFORT_REMINDER = 15; const std::string ADAPTIVE_SWITCH = "ringtone_vibrate_adaptive_switch"; +constexpr const char* USER_STATUS_SO_NAME = "libuser_status_client.z.so"; +constexpr const char* MSDP_SUBSCRIBE_CALLBACK_FUNC_NAME = "SubscribeCallback"; +const char* MSDP_SUBSCRIBE_FUNC_NAME = "Subscribe"; +const char* MSDP_UNSUBSCRIBE_FUNC_NAME = "Unsubscribe"; + +typedef int32_t (*SubscribeCallbackFunc)(uint32_t feature, UserStatusDataCallbackFunc &callback); +typedef int32_t (*SubscribeFunc)(uint32_t feature); +typedef int32_t (*UnsubscribeFunc)(uint32_t feature); #endif Ring::Ring() @@ -60,12 +69,18 @@ void Ring::Init() } audioPlayer_ = std::make_unique(); - if (RingtonePlayer_ != nullptr) { RingtonePlayer_->Stop(); RingtonePlayer_->Release(); RingtonePlayer_.reset(); } +#ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE + userHandle_ = dlopen(USER_STATUS_SO_NAME, RTLD_NOW); + if (userHandle_ == nullptr) { + TELEPHONY_LOGE("user status dlopen failed : %{public}s", dlerror()); + return; + } +#endif } int32_t Ring::Play(int32_t slotId, std::string ringtonePath, Media::HapticStartupMode mode) @@ -211,8 +226,7 @@ void Ring::GetSettingsData() isAdaptiveSwitchOn_ = ringtoneSettingStatus == "true"; } -void Ring::OnComfortReminderDataChanged(int32_t result, - std::shared_ptr comfortReminderData) +void Ring::OnComfortReminderDataChanged(int32_t result, std::shared_ptr comfortReminderData) { if (!isAdaptiveSwitchOn_) { return; @@ -285,41 +299,59 @@ void Ring::SetRingToneVibrationState() int32_t Ring::RegisterUserStatusDataCallbackFunc() { - if (!isAdaptiveSwitchOn_) { + if (!isAdaptiveSwitchOn_ || userHandle_ == nullptr) { return TELEPHONY_SUCCESS; } - Msdp::UserStatusAwareness::UserStatusDataCallbackFunc callback = [this] (int32_t result, - std::shared_ptr userStatusData) { - auto comfortReminderData = - std::static_pointer_cast(userStatusData); - if (comfortReminderData != nullptr) { - OnComfortReminderDataChanged(result, comfortReminderData); - } - }; - int32_t subRet = Msdp::UserStatusAwareness::UserStatusClient::GetInstance().SubscribeCallback( - FEATURE_COMFORT_REMINDER, callback); - TELEPHONY_LOGI("Subscribe User Status Data ret: %{public}d", subRet); - return subRet; + + SubscribeCallbackFunc subscribeCallbackFunc = reinterpret_cast(dlsym(userHandle_, + MSDP_SUBSCRIBE_CALLBACK_FUNC_NAME)); + if (subscribeCallbackFunc == nullptr) { + TELEPHONY_LOGE("dlsym subscribeCallbackFunc failed : %{public}s", dlerror()); + return TELEPHONY_ERROR; + } + + std::function)> callback = [this] (int32_t result, + std::shared_ptr userStatusData) { + std::shared_ptr comfortReminderData = + std::static_pointer_cast(userStatusData); + if (comfortReminderData != nullptr) { + OnComfortReminderDataChanged(result, comfortReminderData); + } + }; + + int32_t subRet = subscribeCallbackFunc(FEATURE_COMFORT_REMINDER, callback); + TELEPHONY_LOGI("Subscribe User Status Data ret: %{public}d", subRet); + return subRet; } int32_t Ring::SubscribeFeature() { - if (!isAdaptiveSwitchOn_) { + if (!isAdaptiveSwitchOn_ || userHandle_ == nullptr) { return TELEPHONY_SUCCESS; } - const std::vector deviceInfoList; - int32_t ret = Msdp::UserStatusAwareness::UserStatusClient::GetInstance().Subscribe( - FEATURE_COMFORT_REMINDER, deviceInfoList); + + SubscribeFunc subscribeFunc = reinterpret_cast(dlsym(userHandle_, MSDP_SUBSCRIBE_FUNC_NAME)); + if (subscribeFunc == nullptr) { + TELEPHONY_LOGE("dlsym SubscribeFunc failed : %{public}s", dlerror()); + return TELEPHONY_ERROR; + } + int32_t ret = subscribeFunc(FEATURE_COMFORT_REMINDER); TELEPHONY_LOGI("ring Subscribe feature, ret = %{public}d", ret); return TELEPHONY_SUCCESS; } int32_t Ring::UnsubscribeFeature() { - if (!isAdaptiveSwitchOn_) { + if (!isAdaptiveSwitchOn_ || userHandle_ == nullptr) { return TELEPHONY_SUCCESS; } - int32_t ret = Msdp::UserStatusAwareness::UserStatusClient::GetInstance().Unsubscribe(FEATURE_COMFORT_REMINDER); + + UnsubscribeFunc unsubscribeFunc = reinterpret_cast(dlsym(userHandle_, MSDP_UNSUBSCRIBE_FUNC_NAME)); + if (unsubscribeFunc == nullptr) { + TELEPHONY_LOGE("dlsym UnsubscribeFunc failed : %{public}s", dlerror()); + return TELEPHONY_ERROR; + } + int32_t ret = unsubscribeFunc(FEATURE_COMFORT_REMINDER); TELEPHONY_LOGI("ring Unsubscribe feature, ret = %{public}d", ret); return TELEPHONY_SUCCESS; } @@ -334,6 +366,7 @@ void Ring::ResetComfortReminder() isGentleHappend_ = false; isFadeupHappend_ = false; } + void Ring::PrepareComfortReminder() { if (!isAdaptiveSwitchOn_) { @@ -381,8 +414,8 @@ void Ring::DecreaseVolume() [this] {return isRingStopped_; })) { TELEPHONY_LOGI("DecreaseVolume interrupt by ring stop"); return; - } - lock.unlock(); + } + lock.unlock(); ringVolume--; float endVolumeDb = audioProxy->GetSystemRingVolumeInDb(ringVolume); SetRingToneVolume(endVolumeDb / oriVolumeDb_); diff --git a/test/unittest/call_manager_special_test/BUILD.gn b/test/unittest/call_manager_special_test/BUILD.gn index 1706e0a168f13ce508146ea35dcbb880cd321d3c..8e473df9f50e4bd46f787f8d837e69c9c5975929 100644 --- a/test/unittest/call_manager_special_test/BUILD.gn +++ b/test/unittest/call_manager_special_test/BUILD.gn @@ -151,12 +151,6 @@ ohos_unittest("tel_call_manager_special1_test") { global_parts_info.multimedia_camera_framework) { external_deps += [ "camera_framework:camera_framework" ] } - - if (defined(global_parts_info) && - defined(global_parts_info.msdp_user_status_awareness) && - global_parts_info.msdp_user_status_awareness) { - external_deps += [ "user_status_awareness::user_status_client" ] - } } ohos_unittest("tel_call_manager_special2_test") { @@ -295,12 +289,6 @@ ohos_unittest("tel_call_manager_special2_test") { global_parts_info.multimedia_camera_framework) { external_deps += [ "camera_framework:camera_framework" ] } - - if (defined(global_parts_info) && - defined(global_parts_info.msdp_user_status_awareness) && - global_parts_info.msdp_user_status_awareness) { - external_deps += [ "user_status_awareness::user_status_client" ] - } } ohos_unittest("tel_call_manager_special3_test") { @@ -440,10 +428,4 @@ ohos_unittest("tel_call_manager_special3_test") { global_parts_info.multimedia_camera_framework) { external_deps += [ "camera_framework:camera_framework" ] } - - if (defined(global_parts_info) && - defined(global_parts_info.msdp_user_status_awareness) && - global_parts_info.msdp_user_status_awareness) { - external_deps += [ "user_status_awareness::user_status_client" ] - } } \ No newline at end of file diff --git a/test/unittest/call_manager_zero_gtest/src/zero_branch_test_call_state.cpp b/test/unittest/call_manager_zero_gtest/src/zero_branch_test_call_state.cpp index 8c33cb08ff1e8bc46d93794deea8cd9262afed4a..3c44f95cf56bd7cae972a6402c861ea22e2d301e 100644 --- a/test/unittest/call_manager_zero_gtest/src/zero_branch_test_call_state.cpp +++ b/test/unittest/call_manager_zero_gtest/src/zero_branch_test_call_state.cpp @@ -457,7 +457,7 @@ HWTEST_F(CallStateTest, Telephony_Ring_002, TestSize.Level0) { #ifdef OHOS_SUBSCRIBE_USER_STATUS_ENABLE auto ring = std::make_shared(); - auto comfortReminder = std::make_shared(); + auto comfortReminder = std::make_shared(); comfortReminder->SetFusionReminderData(0); comfortReminder->SetEventType(1); ring->isAdaptiveSwitchOn_ = true;