diff --git a/bundle.json b/bundle.json index dd372a530afcd5ee6d5105410760f1251e811a73..fe07fe75d4154f55d4f29886e7ed5fbbb6f0dd73 100644 --- a/bundle.json +++ b/bundle.json @@ -13,7 +13,8 @@ "features": [ "miscdevice_feature_vibrator_custom", "miscdevice_feature_vibrator_input_method_enable", - "miscdevice_feature_crown_vibrator_enable" + "miscdevice_feature_crown_vibrator_enable", + "miscdevice_feature_do_not_disturb_enable" ], "adapted_system_type": [ "standard" ], "rom": "1024KB", diff --git a/hisysevent.yaml b/hisysevent.yaml index 9e631304658b6d9f7dd4badd3d85a47d7ec02e11..e898a1b35cbbf830c27560ac7fa39984206c01c6 100644 --- a/hisysevent.yaml +++ b/hisysevent.yaml @@ -41,4 +41,19 @@ MISC_SERVICE_EXCEPTION: SWITCHES_TOGGLE: __BASE: {type: BEHAVIOR, level: CRITICAL, desc: Switching, preserve: true} SWITCH_TYPE: {type: STRING, desc: Switch Type} - STATUS: {type: INT32, desc: Switch status} \ No newline at end of file + STATUS: {type: INT32, desc: Switch status} + +DATASHARE_EXCEPTION: + __BASE: {type: FAULT, level: MINOR, desc: miscdevice service datashare exception} + PKG_NAME: {type: STRING, desc: package name} + ERROR_CODE: {type: INT32, desc: error code} + +WHITELIST_COUNT_EXCEPTION: + __BASE: {type: FAULT, level: MINOR, desc: miscdevice service whitelist exception} + PKG_NAME: {type: STRING, desc: package name} + ACTUAL_COUNT: {type: INT32, desc: white list actual count} + +USER_SWITCHED_EXCEPTION: + __BASE: {type: FAULT, level: MINOR, desc: miscdevice service user switched exception} + PKG_NAME: {type: STRING, desc: package name} + ERROR_CODE: {type: INT32, desc: error code} \ No newline at end of file diff --git a/miscdevice.gni b/miscdevice.gni index ce48b6fb22eec8ebaca417cc0fe284b59fc17187..40c1f0a5f9f770f510005a80648caa3fa508267c 100644 --- a/miscdevice.gni +++ b/miscdevice.gni @@ -18,6 +18,7 @@ declare_args() { miscdevice_feature_hiviewdfx_hisysevent = true miscdevice_feature_vibrator_input_method_enable = true miscdevice_feature_crown_vibrator_enable = false + miscdevice_feature_do_not_disturb_enable = false } print( @@ -41,6 +42,10 @@ if (miscdevice_feature_crown_vibrator_enable) { miscdevice_default_defines += [ "OHOS_BUILD_ENABLE_VIBRATOR_CROWN" ] } +if (miscdevice_feature_do_not_disturb_enable) { + miscdevice_default_defines += [ "OHOS_BUILD_ENABLE_DO_NOT_DISTURB" ] +} + if (!defined(global_parts_info) || defined(global_parts_info.hdf_drivers_interface_light)) { hdf_drivers_interface_light = true diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h index 0a4b53111628898ebc99bd7243c4733be31891d2..2c159524be4e7190d15986eb7ae0ce9a5896f767 100644 --- a/services/miscdevice_service/include/miscdevice_service.h +++ b/services/miscdevice_service/include/miscdevice_service.h @@ -90,6 +90,9 @@ private: void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; int32_t SubscribeCommonEvent(const std::string &eventName, EventReceiver receiver); void OnReceiveEvent(const EventFwk::CommonEventData &data); +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + void OnReceiveUserSwitchEvent(const EventFwk::CommonEventData &data); +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter); int32_t PlayPatternCheckAuthAndParam(int32_t usage, const VibrateParameter ¶meter); int32_t PlayPrimitiveEffectCheckAuthAndParam(int32_t intensity, int32_t usage); diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index 0dda2e0bd52b51c25450724d7934a7e2ab80343c..b78cafe31121cdf2b216e5e2ce1f838157ab45dc 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -17,6 +17,9 @@ #define VIBRATION_PRIORITY_MANAGER_H #include "app_mgr_client.h" +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +#include "cJSON.h" +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #include "datashare_helper.h" #include "miscdevice_observer.h" @@ -59,12 +62,31 @@ enum FeedbackIntensity { }; #endif +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +enum DoNotDisturbSwitch { + DONOTDISTURB_SWITCH_INVALID = -1, + DONOTDISTURB_SWITCH_OFF = 0, + DONOTDISTURB_SWITCH_ON = 1 +}; + +struct WhiteListAppInfo { + std::string bundle; + int64_t uid; +}; +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + class VibrationPriorityManager { DECLARE_DELAYED_SINGLETON(VibrationPriorityManager); public: DISALLOW_COPY_AND_MOVE(VibrationPriorityManager); bool Init(); VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, std::shared_ptr vibratorThread); +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + void InitDoNotDisturbData(); + void UpdateCurrentUserId(); + int32_t RegisterUserObserver(); + int32_t UnregisterUserObserver(); +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN bool ShouldIgnoreByIntensity(const VibrateInfo &vibrateInfo); void MiscCrownIntensityFeedbackInit(void); @@ -83,8 +105,18 @@ private: int32_t GetIntValue(const std::string &key, int32_t &value); int32_t GetLongValue(const std::string &key, int64_t &value); int32_t GetStringValue(const std::string &key, std::string &value); +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + int32_t GetDoNotDisturbStringValue(const std::string &key, std::string &value); + int32_t GetDoNotDisturbIntValue(const std::string &key, int32_t &value); + int32_t GetDoNotDisturbLongValue(const std::string &key, int64_t &value); + int32_t GetWhiteListValue(const std::string &key, std::vector &value); + void DeleteCJSONValue(cJSON *jsonValue); + bool IgnoreAppVibrations(const VibrateInfo &vibrateInfo); + std::string ReplaceUserIdForUri(std::string uri, int32_t userId); + Uri DoNotDisturbAssembleUri(const std::string &key); +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB Uri AssembleUri(const std::string &key); - std::shared_ptr CreateDataShareHelper(); + std::shared_ptr CreateDataShareHelper(const std::string &tableUrl); bool ReleaseDataShareHelper(std::shared_ptr &helper); sptr CreateObserver(const MiscDeviceObserver::UpdateFunc &func); void UpdateStatus(); @@ -95,6 +127,11 @@ private: std::shared_ptr appMgrClientPtr_ {nullptr}; std::atomic_int32_t miscFeedback_ = FEEDBACK_MODE_INVALID; std::atomic_int32_t miscAudioRingerMode_ = RINGER_MODE_INVALID; +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + std::atomic_int32_t doNotDisturbSwitch_ = DONOTDISTURB_SWITCH_INVALID; + std::vector doNotDisturbWhiteList_; + sptr currentUserObserver_; +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN std::atomic_int32_t miscCrownFeedback_ = FEEDBACK_MODE_INVALID; std::atomic_int32_t miscIntensity_ = FEEDBACK_INTENSITY_INVALID; diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index eb5b44d0a188b62fa7a6d1648ff07cbcc0acd4eb..c38f48ca872064f78036ab233393da0b2e9c4b5d 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -15,6 +15,9 @@ #include "miscdevice_service.h" +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + #include "common_event_support.h" +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #include "death_recipient_template.h" #ifdef HIVIEWDFX_HISYSEVENT_ENABLE #include "hisysevent.h" @@ -130,6 +133,13 @@ void MiscdeviceService::OnAddSystemAbility(int32_t systemAbilityId, const std::s if (ret != ERR_OK) { MISC_HILOGE("Subscribe usual.event.DATA_SHARE_READY fail"); } +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + ret = SubscribeCommonEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED, + std::bind(&MiscdeviceService::OnReceiveUserSwitchEvent, this, std::placeholders::_1)); + if (ret != ERR_OK) { + MISC_HILOGE("Subscribe usual.event.USER_SWITCHED fail"); + } +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID); break; } @@ -171,6 +181,24 @@ void MiscdeviceService::OnReceiveEvent(const EventFwk::CommonEventData &data) } } +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +void MiscdeviceService::OnReceiveUserSwitchEvent(const EventFwk::CommonEventData &data) +{ + const auto &want = data.GetWant(); + std::string action = want.GetAction(); + if (action == EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED) { + MISC_HILOGI("OnReceiveUserSwitchEvent user switched"); + PriorityManager->UnregisterUserObserver(); + PriorityManager->UpdateCurrentUserId(); + PriorityManager->RegisterUserObserver(); +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "USER_SWITCHED_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "OnReceiveUserSwitchEvent", "ERROR_CODE", ERR_OK); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + } +} +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + void MiscdeviceService::OnStart() { CALL_LOG_ENTER; diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index 05f2516cd7edac705b5272e37942f0d38f84d354..b7bc872297723ca8fc2c09e3dbe9256ae3aa60c1 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -16,6 +16,9 @@ #include "vibration_priority_manager.h" #include +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +#include +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #include "accesstoken_kit.h" #ifdef HIVIEWDFX_HISYSEVENT_ENABLE @@ -38,6 +41,12 @@ namespace OHOS { namespace Sensors { using namespace OHOS::HiviewDFX; +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +const int32_t INVALID_USERID = 100; +const int32_t WHITE_LIST_MAX_COUNT = 100; +static int32_t g_currentUserId = INVALID_USERID; +static std::mutex g_settingMutex; +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB namespace { const std::string SETTING_COLUMN_KEYWORD = "KEYWORD"; const std::string SETTING_COLUMN_VALUE = "VALUE"; @@ -46,6 +55,15 @@ const std::string SETTING_RINGER_MODE_KEY = "ringer_mode"; const std::string SETTING_URI_PROXY = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true"; const std::string SCENEBOARD_BUNDLENAME = "com.ohos.sceneboard"; constexpr const char *SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility"; +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +const std::string USER_SETTING_SECURE_URI_PROXY = "datashare:///com.ohos.settingsdata/entry/settingsdata/" + "USER_SETTINGSDATA_SECURE_##USERID##?Proxy=true"; +const std::string DO_NOT_DISTURB_SWITCH = "focus_mode_enable"; +const std::string DO_NOT_DISTURB_WHITE_LIST = "intelligent_scene_notification_white_list"; +const std::string WHITE_LIST_KEY_BUNDLE = "bundle"; +const std::string WHITE_LIST_KEY_UID = "uid"; +constexpr const char *USERID_REPLACE = "##USERID##"; +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN const std::string SETTING_CROWN_FEEDBACK_KEY = "watch_crown_feedback_enabled"; const std::string SETTING_VIBRATE_INTENSITY_KEY = "vibration_intensity_index"; @@ -63,6 +81,11 @@ VibrationPriorityManager::~VibrationPriorityManager() if (UnregisterObserver(observer_) != ERR_OK) { MISC_HILOGE("UnregisterObserver failed"); } +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + if (UnregisterUserObserver() != ERR_OK) { + MISC_HILOGE("UnregisterUserObserver failed"); + } +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB } bool VibrationPriorityManager::Init() @@ -114,6 +137,306 @@ bool VibrationPriorityManager::Init() return true; } +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB +void VibrationPriorityManager::InitDoNotDisturbData() +{ + int32_t switchTemp = doNotDisturbSwitch_; + if (GetDoNotDisturbIntValue(DO_NOT_DISTURB_SWITCH, switchTemp) != ERR_OK) { + doNotDisturbSwitch_ = DONOTDISTURB_SWITCH_OFF; + MISC_HILOGE("Get doNotDisturbSwitch failed"); + } else { + doNotDisturbSwitch_ = switchTemp; + MISC_HILOGI("doNotDisturbSwitch:%{public}d", switchTemp); + } + if (doNotDisturbSwitch_ == DONOTDISTURB_SWITCH_ON) { + std::vector whiteListTemp; + int32_t whiteListRet = GetWhiteListValue(DO_NOT_DISTURB_WHITE_LIST, whiteListTemp); + if (whiteListRet != ERR_OK) { + doNotDisturbSwitch_ = DONOTDISTURB_SWITCH_OFF; +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "DATASHARE_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "GetWhiteListValue", "ERROR_CODE", whiteListRet); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("Get doNotDisturbWhiteList failed"); + } else { + int32_t whiteListSize = static_cast(whiteListTemp.size()); + if (whiteListSize > WHITE_LIST_MAX_COUNT) { + doNotDisturbWhiteList_.clear(); + doNotDisturbWhiteList_.assign(whiteListTemp.begin(), whiteListTemp.begin() + WHITE_LIST_MAX_COUNT); +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "WHITELIST_COUNT_EXCEPTION", + HiSysEvent::EventType::FAULT, "PKG_NAME", "InitDoNotDisturbData", "ACTUAL_COUNT", whiteListSize); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGW("whiteListTemp size:%{public}d", whiteListSize); + } else { + doNotDisturbWhiteList_ = whiteListTemp; + } + MISC_HILOGI("doNotDisturbWhiteList size:%{public}d", static_cast(doNotDisturbWhiteList_.size())); + } + } else if (doNotDisturbSwitch_ == DONOTDISTURB_SWITCH_OFF) { + doNotDisturbWhiteList_.clear(); + MISC_HILOGD("clear doNotDisturbWhiteList_, DoNotDisturbSwitch:%{public}d", + static_cast(doNotDisturbSwitch_)); + } else { + MISC_HILOGW("DoNotDisturbSwitch invalid, DoNotDisturbSwitch:%{public}d", + static_cast(doNotDisturbSwitch_)); + } +} + +void VibrationPriorityManager::UpdateCurrentUserId() +{ + std::lock_guard lock(g_settingMutex); + std::vector activeUserIds; + int retId = AccountSA::OsAccountManager::QueryActiveOsAccountIds(activeUserIds); + if (retId != 0) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "USER_SWITCHED_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "QueryActiveOsAccountIds", "ERROR_CODE", retId); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("QueryActiveOsAccountIds failed %{public}d", retId); + return; + } + if (activeUserIds.empty()) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "USER_SWITCHED_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "activeUserIdsEmpty", "ERROR_CODE", ERROR); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("activeUserIds empty"); + return; + } + g_currentUserId = activeUserIds[0]; +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "USER_SWITCHED_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "UpdateCurrentUserId", "ERROR_CODE", ERR_OK); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGI("g_currentUserId is %{public}d", g_currentUserId); +} + +int32_t VibrationPriorityManager::RegisterUserObserver() +{ + MISC_HILOGI("RegisterUserObserver start"); + MiscDeviceObserver::UpdateFunc updateFunc = [&]() { InitDoNotDisturbData(); }; + currentUserObserver_ = CreateObserver(updateFunc); + if (currentUserObserver_ == nullptr) { + MISC_HILOGE("currentUserObserver_ is null"); + return MISC_NO_INIT_ERR; + } + std::string callingIdentity = IPCSkeleton::ResetCallingIdentity(); + auto doNotDisturbHelper = + CreateDataShareHelper(ReplaceUserIdForUri(USER_SETTING_SECURE_URI_PROXY, g_currentUserId)); + if (doNotDisturbHelper == nullptr) { + IPCSkeleton::SetCallingIdentity(callingIdentity); +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "DATASHARE_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "RegisterUserObserver", "ERROR_CODE", MISC_NO_INIT_ERR); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("doNotDisturbHelper is nullptr"); + return MISC_NO_INIT_ERR; + } + auto doNotDisturbSwitch = DoNotDisturbAssembleUri(DO_NOT_DISTURB_SWITCH); + doNotDisturbHelper->RegisterObserver(doNotDisturbSwitch, currentUserObserver_); + doNotDisturbHelper->NotifyChange(doNotDisturbSwitch); + auto doNotDisturbWhiteList = DoNotDisturbAssembleUri(DO_NOT_DISTURB_WHITE_LIST); + doNotDisturbHelper->RegisterObserver(doNotDisturbWhiteList, currentUserObserver_); + doNotDisturbHelper->NotifyChange(doNotDisturbWhiteList); + std::thread execCb(VibrationPriorityManager::ExecRegisterCb, currentUserObserver_); + execCb.detach(); + ReleaseDataShareHelper(doNotDisturbHelper); + IPCSkeleton::SetCallingIdentity(callingIdentity); + MISC_HILOGI("Succeed to RegisterUserObserver of uri"); + return ERR_OK; +} + +int32_t VibrationPriorityManager::UnregisterUserObserver() +{ + MISC_HILOGI("UnregisterUserObserver start"); + if (currentUserObserver_ == nullptr) { + MISC_HILOGE("currentUserObserver_ is nullptr"); + return MISC_NO_INIT_ERR; + } + std::string callingIdentity = IPCSkeleton::ResetCallingIdentity(); + auto doNotDisturbHelper = + CreateDataShareHelper(ReplaceUserIdForUri(USER_SETTING_SECURE_URI_PROXY, g_currentUserId)); + if (doNotDisturbHelper == nullptr) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "DATASHARE_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "UnregisterUserObserver", "ERROR_CODE", MISC_NO_INIT_ERR); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + IPCSkeleton::SetCallingIdentity(callingIdentity); + currentUserObserver_ = nullptr; + MISC_HILOGE("doNotDisturbHelper is nullptr"); + return MISC_NO_INIT_ERR; + } + auto doNotDisturbSwitch = DoNotDisturbAssembleUri(DO_NOT_DISTURB_SWITCH); + doNotDisturbHelper->UnregisterObserver(doNotDisturbSwitch, currentUserObserver_); + auto doNotDisturbWhiteList = DoNotDisturbAssembleUri(DO_NOT_DISTURB_WHITE_LIST); + doNotDisturbHelper->UnregisterObserver(doNotDisturbWhiteList, currentUserObserver_); + ReleaseDataShareHelper(doNotDisturbHelper); + IPCSkeleton::SetCallingIdentity(callingIdentity); + currentUserObserver_ = nullptr; + MISC_HILOGI("Succeed to UnregisterUserObserver observer"); + return ERR_OK; +} + +std::string VibrationPriorityManager::ReplaceUserIdForUri(std::string uri, int32_t userId) +{ + std::string tempUri = uri; + std::regex pattern(USERID_REPLACE); + return std::regex_replace(tempUri, pattern, std::to_string(userId)); +} + +Uri VibrationPriorityManager::DoNotDisturbAssembleUri(const std::string &key) +{ + Uri uri(ReplaceUserIdForUri(USER_SETTING_SECURE_URI_PROXY, g_currentUserId) + "&key=" + key); + return uri; +} + +int32_t VibrationPriorityManager::GetDoNotDisturbStringValue(const std::string &key, std::string &value) +{ + std::string callingIdentity = IPCSkeleton::ResetCallingIdentity(); + auto helper = CreateDataShareHelper(ReplaceUserIdForUri(USER_SETTING_SECURE_URI_PROXY, g_currentUserId)); + if (helper == nullptr) { + IPCSkeleton::SetCallingIdentity(callingIdentity); + MISC_HILOGE("helper is nullptr"); + return MISC_NO_INIT_ERR; + } + std::vector columns = { SETTING_COLUMN_VALUE }; + DataShare::DataSharePredicates predicates; + predicates.EqualTo(SETTING_COLUMN_KEYWORD, key); + Uri uri(DoNotDisturbAssembleUri(key)); + auto resultSet = helper->Query(uri, predicates, columns); + ReleaseDataShareHelper(helper); + if (resultSet == nullptr) { + MISC_HILOGE("resultSet is nullptr"); + IPCSkeleton::SetCallingIdentity(callingIdentity); + return MISC_INVALID_OPERATION_ERR; + } + int32_t count; + resultSet->GetRowCount(count); + if (count == 0) { + MISC_HILOGW("Not found value, key:%{public}s, count:%{public}d", key.c_str(), count); + IPCSkeleton::SetCallingIdentity(callingIdentity); + return MISC_NAME_NOT_FOUND_ERR; + } + const int32_t index = 0; + resultSet->GoToRow(index); + int32_t ret = resultSet->GetString(index, value); + if (ret != ERR_OK) { + MISC_HILOGW("GetString failed, ret:%{public}d", ret); + IPCSkeleton::SetCallingIdentity(callingIdentity); + return ERROR; + } + resultSet->Close(); + IPCSkeleton::SetCallingIdentity(callingIdentity); + return ERR_OK; +} + +int32_t VibrationPriorityManager::GetDoNotDisturbIntValue(const std::string &key, int32_t &value) +{ + int64_t valueLong; + int32_t ret = GetDoNotDisturbLongValue(key, valueLong); + if (ret != ERR_OK) { + MISC_HILOGE("GetDoNotDisturbLongValue failed, ret:%{public}d", ret); + return ret; + } + value = static_cast(valueLong); + return ERR_OK; +} + +int32_t VibrationPriorityManager::GetDoNotDisturbLongValue(const std::string &key, int64_t &value) +{ + std::string valueStr; + int32_t ret = GetDoNotDisturbStringValue(key, valueStr); + if (ret != ERR_OK) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "DATASHARE_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "GetDoNotDisturbStringValue", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("GetDoNotDisturbStringValue failed, ret:%{public}d", ret); + return ret; + } + value = static_cast(strtoll(valueStr.c_str(), nullptr, DECEM_BASE)); + return ERR_OK; +} + +int32_t VibrationPriorityManager::GetWhiteListValue(const std::string &key, std::vector &value) +{ + std::string valueStr; + int32_t ret = GetDoNotDisturbStringValue(key, valueStr); + if (ret != ERR_OK) { + MISC_HILOGE("GetDoNotDisturbStringValue failed, ret:%{public}d", ret); + return ret; + } + if (valueStr.empty()) { + MISC_HILOGE("String value empty"); + return ERROR; + } + cJSON *jsonArray = nullptr; + jsonArray = cJSON_Parse(valueStr.c_str()); + if (!cJSON_IsArray(jsonArray)) { + MISC_HILOGE("The string value is not array"); + DeleteCJSONValue(jsonArray); + return ERROR; + } + int32_t size = cJSON_GetArraySize(jsonArray); + for (int32_t i = 0; i < size; ++i) { + cJSON *valJson = cJSON_GetArrayItem(jsonArray, i); + if (!cJSON_IsObject(valJson)) { + MISC_HILOGE("The json is not object"); + DeleteCJSONValue(jsonArray); + return ERROR; + } + if (!cJSON_HasObjectItem(valJson, WHITE_LIST_KEY_BUNDLE.c_str()) || + !cJSON_HasObjectItem(valJson, WHITE_LIST_KEY_UID.c_str())) { + MISC_HILOGE("The json is not bundle or uid"); + DeleteCJSONValue(jsonArray); + return ERROR; + } + WhiteListAppInfo whiteListAppInfo; + cJSON *valBundle = cJSON_GetObjectItem(valJson, WHITE_LIST_KEY_BUNDLE.c_str()); + cJSON *valUid = cJSON_GetObjectItem(valJson, WHITE_LIST_KEY_UID.c_str()); + if ((!cJSON_IsString(valBundle)) || !cJSON_IsNumber(valUid)) { + MISC_HILOGE("The value of index %{public}d is not match", i); + DeleteCJSONValue(jsonArray); + return ERROR; + } + whiteListAppInfo.bundle = valBundle->valuestring; + whiteListAppInfo.uid = static_cast(valUid->valueint); + value.push_back(whiteListAppInfo); + } + DeleteCJSONValue(jsonArray); + return ERR_OK; +} + +void VibrationPriorityManager::DeleteCJSONValue(cJSON *jsonValue) +{ + if (jsonValue != nullptr) { + cJSON_Delete(jsonValue); + } +} + +bool VibrationPriorityManager::IgnoreAppVibrations(const VibrateInfo &vibrateInfo) +{ + if (vibrateInfo.usage != USAGE_NOTIFICATION && vibrateInfo.usage != USAGE_RING) { + MISC_HILOGD("Vibration is not ignored , usage:%{public}d", vibrateInfo.usage); + return false; + } + if (doNotDisturbSwitch_ != DONOTDISTURB_SWITCH_ON) { + MISC_HILOGD("DoNotDisturbSwitch is off"); + return false; + } + for (const WhiteListAppInfo &whiteListAppInfo : doNotDisturbWhiteList_) { + if (vibrateInfo.packageName == whiteListAppInfo.bundle) { + MISC_HILOGD("Not ignore app vibration, the app is on the whitelist, bundleName::%{public}s", + vibrateInfo.packageName.c_str()); + return false; + } + } + MISC_HILOGI("Ignore app vibration, bundleName::%{public}s", vibrateInfo.packageName.c_str()); + return true; +} +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN void VibrationPriorityManager::MiscCrownIntensityFeedbackInit(void) { @@ -166,6 +489,11 @@ int32_t VibrationPriorityManager::GetLongValue(const std::string &key, int64_t & std::string valueStr; int32_t ret = GetStringValue(key, valueStr); if (ret != ERR_OK) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "DATASHARE_EXCEPTION", HiSysEvent::EventType::FAULT, + "PKG_NAME", "GetStringValue", "ERROR_CODE", ret); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGE("GetStringValue failed, ret:%{public}d", ret); return ret; } value = static_cast(strtoll(valueStr.c_str(), nullptr, DECEM_BASE)); @@ -175,7 +503,7 @@ int32_t VibrationPriorityManager::GetLongValue(const std::string &key, int64_t & int32_t VibrationPriorityManager::GetStringValue(const std::string &key, std::string &value) { std::string callingIdentity = IPCSkeleton::ResetCallingIdentity(); - auto helper = CreateDataShareHelper(); + auto helper = CreateDataShareHelper(SETTING_URI_PROXY); if (helper == nullptr) { IPCSkeleton::SetCallingIdentity(callingIdentity); return MISC_NO_INIT_ERR; @@ -229,6 +557,11 @@ void VibrationPriorityManager::UpdateStatus() } miscAudioRingerMode_ = ringerMode; } +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + if (doNotDisturbSwitch_ == DONOTDISTURB_SWITCH_INVALID) { + InitDoNotDisturbData(); + } +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN if (miscCrownFeedback_ == FEEDBACK_MODE_INVALID) { int32_t corwnfeedback = FEEDBACK_MODE_INVALID; @@ -327,6 +660,12 @@ VibrateStatus VibrationPriorityManager::ShouldIgnoreVibrate(const VibrateInfo &v { UpdateStatus(); if (!IsSystemCalling() || vibrateInfo.systemUsage == false) { +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + if (IgnoreAppVibrations(vibrateInfo)) { + MISC_HILOGD("Vibration is ignored for doNotDisturb, usage:%{public}d", vibrateInfo.usage); + return IGNORE_GLOBAL_SETTINGS; + } +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB if ((vibrateInfo.usage == USAGE_ALARM || vibrateInfo.usage == USAGE_RING || vibrateInfo.usage == USAGE_NOTIFICATION || vibrateInfo.usage == USAGE_COMMUNICATION) && (miscAudioRingerMode_ == RINGER_MODE_SILENT)) { @@ -415,17 +754,17 @@ Uri VibrationPriorityManager::AssembleUri(const std::string &key) return uri; } -std::shared_ptr VibrationPriorityManager::CreateDataShareHelper() +std::shared_ptr VibrationPriorityManager::CreateDataShareHelper(const std::string &tableUrl) { if (remoteObj_ == nullptr) { MISC_HILOGE("remoteObj_ is nullptr"); return nullptr; } - auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj_, SETTING_URI_PROXY, SETTINGS_DATA_EXT_URI); + auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj_, tableUrl, SETTINGS_DATA_EXT_URI); if (ret == DATA_SHARE_READY) { return helper; } else if (ret == DATA_SHARE_NOT_READY) { - MISC_HILOGE("Create data_share helper failed, uri proxy:%{public}s", SETTING_URI_PROXY.c_str()); + MISC_HILOGE("Create data_share helper failed, uri proxy:%{public}s", tableUrl.c_str()); return nullptr; } MISC_HILOGI("Data_share create unknown"); @@ -457,8 +796,12 @@ int32_t VibrationPriorityManager::RegisterObserver(const sptr