From 8e4aca8e8448203db9841635341e4002794fd566 Mon Sep 17 00:00:00 2001 From: shenpeixing Date: Fri, 12 Sep 2025 15:45:37 +0800 Subject: [PATCH] =?UTF-8?q?miscdevice=E6=9C=8D=E5=8A=A1=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=E7=BB=B4=E6=B5=8B=E6=89=93=E7=82=B9=E4=BF=A1=E6=81=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shenpeixing --- hisysevent.yaml | 15 ++- .../include/miscdevice_service.h | 11 ++ .../include/vibration_priority_manager.h | 3 + .../src/miscdevice_service.cpp | 100 ++++++++++++++++++ .../src/vibration_priority_manager.cpp | 63 ++++++++++- 5 files changed, 189 insertions(+), 3 deletions(-) diff --git a/hisysevent.yaml b/hisysevent.yaml index 1e8b2c8..b151d18 100644 --- a/hisysevent.yaml +++ b/hisysevent.yaml @@ -56,4 +56,17 @@ WHITELIST_COUNT_EXCEPTION: USER_SWITCHED_EXCEPTION: __BASE: {type: FAULT, level: CRITICAL, desc: user switched exception, preserve: true} PKG_NAME: {type: STRING, desc: package name} - ERROR_CODE: {type: INT32, desc: error code} \ No newline at end of file + ERROR_CODE: {type: INT32, desc: error code} + +VIBRATOR_MODES_STATISTICS: + __BASE: {type: STATISTIC, level: MINOR, desc: vibrator modes statistics, preserve: true} + TIME_MODE_CALL_TIMES: {type: INT32, desc: time mode call times} + PRESET_MODE_CALL_TIMES: {type: INT32, desc: preset mode call times} + FILE_MODE_CALL_TIMES: {type: INT32, desc: file mode call times} + PATTERN_MODE_CALL_TIMES: {type: INT32, desc: pattern mode call times} + +INVALID_VIBRATOR_STATISTICS: + __BASE: {type: STATISTIC, level: MINOR, desc: invalid vibrator statistics, preserve: true} + PKG_NAME: {type: STRING, desc: package name} + INVALID_VIBRATOR_ID: {type: INT32, desc: invalid vibrator id} + CALL_TIMES: {type: INT32, desc: call times} \ No newline at end of file diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h index ee13923..7ed8bf6 100644 --- a/services/miscdevice_service/include/miscdevice_service.h +++ b/services/miscdevice_service/include/miscdevice_service.h @@ -163,6 +163,17 @@ private: const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos); int32_t PerformVibrationControl(const VibratorIdentifierIPC& identifier, int32_t duration, VibrateInfo& info); bool IsVibratorIdValid(const std::vector baseInfo, int32_t target); + void ReportCallTimes(); + void SaveInvalidVibratorIdCallTimesInfo(const std::string &pageName, int32_t invalidVibratorId); + void ReportInvalidVibratorIdCallTimes(); + static std::atomic_int32_t timeModeCallTimes_; + static std::atomic_int32_t presetModeCallTimes_; + static std::atomic_int32_t fileModeCallTimes_; + static std::atomic_int32_t patternModeCallTimes_; + static std::atomic_bool stop_; + static std::map> invalidVibratorIdCallTimesMap_; + std::thread reportCallTimesThread_; + std::mutex invalidVibratorIdCallTimesMutex_; std::mutex isVibrationPriorityReadyMutex_; static bool isVibrationPriorityReady_; VibratorHdiConnection &vibratorHdiConnection_ = VibratorHdiConnection::GetInstance(); diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h index f727f86..1f4760c 100644 --- a/services/miscdevice_service/include/vibration_priority_manager.h +++ b/services/miscdevice_service/include/vibration_priority_manager.h @@ -125,6 +125,9 @@ private: void UpdateStatus(); bool IsSystemServiceCalling(); bool IsSystemCalling(); + void ReportSwitchStatus(); + std::thread reportSwitchStatusThread_; + static std::atomic_bool stop_; sptr remoteObj_ { nullptr }; sptr observer_ { nullptr }; std::shared_ptr appMgrClientPtr_ {nullptr}; diff --git a/services/miscdevice_service/src/miscdevice_service.cpp b/services/miscdevice_service/src/miscdevice_service.cpp index ffb16c8..15b2109 100644 --- a/services/miscdevice_service/src/miscdevice_service.cpp +++ b/services/miscdevice_service/src/miscdevice_service.cpp @@ -68,6 +68,9 @@ constexpr int32_t INVALID_PID = -1; constexpr int32_t BASE_YEAR = 1900; constexpr int32_t BASE_MON = 1; constexpr int32_t CONVERSION_RATE = 1000; +constexpr int32_t HOURS_IN_DAY = 24; +constexpr int32_t MINUTES_IN_HOUR = 60; +constexpr int32_t SECONDS_IN_MINUTE = 60; #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM const std::string PHONE_TYPE = "phone"; #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM @@ -77,6 +80,12 @@ constexpr int32_t SHORT_VIBRATOR_DURATION = 50; constexpr int32_t LOG_COUNT_FIVE = 5; } // namespace +std::atomic_int32_t MiscdeviceService::timeModeCallTimes_ = 0; +std::atomic_int32_t MiscdeviceService::presetModeCallTimes_ = 0; +std::atomic_int32_t MiscdeviceService::fileModeCallTimes_ = 0; +std::atomic_int32_t MiscdeviceService::patternModeCallTimes_ = 0; +std::atomic_bool MiscdeviceService::stop_ = false; +std::map> MiscdeviceService::invalidVibratorIdCallTimesMap_; bool MiscdeviceService::isVibrationPriorityReady_ = false; std::map MiscdeviceService::devicesManageMap_; std::map, int32_t> MiscdeviceService::clientPidMap_; @@ -104,6 +113,10 @@ MiscdeviceService::~MiscdeviceService() StopVibratorService(identifier); it = devicesManageMap_.erase(it); } + if (reportCallTimesThread_.joinable()) { + stop_ = true; + reportCallTimesThread_.join(); + } } void MiscdeviceService::OnDump() @@ -250,6 +263,7 @@ void MiscdeviceService::OnStart() #endif // MEMMGR_ENABLE AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID); RegisterVibratorPlugCb(); + reportCallTimesThread_ = std::thread([this]() { this->ReportCallTimes(); }); } int32_t MiscdeviceService::RegisterVibratorPlugCb() @@ -379,6 +393,7 @@ bool MiscdeviceService::ShouldIgnoreVibrate(const VibrateInfo &info, const Vibra int32_t MiscdeviceService::Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut, int32_t usage, bool systemUsage) { + timeModeCallTimes_ += 1; PermissionUtil &permissionUtil = PermissionUtil::GetInstance(); int32_t ret = permissionUtil.CheckVibratePermission(this->GetCallingTokenID(), VIBRATE_PERMISSION); if (ret != PERMISSION_GRANTED) { @@ -477,6 +492,7 @@ int32_t MiscdeviceService::StopVibratorService(const VibratorIdentifierIPC& iden int32_t MiscdeviceService::PlayVibratorEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, int32_t count, int32_t usage, bool systemUsage) { + presetModeCallTimes_ += 1; int32_t checkResult = PlayVibratorEffectCheckAuthAndParam(count, usage); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); @@ -674,6 +690,7 @@ std::string MiscdeviceService::GetCurrentTime() int32_t MiscdeviceService::PlayVibratorCustom(const VibratorIdentifierIPC& identifier, int32_t fd, int64_t offset, int64_t length, const CustomHapticInfoIPC& customHapticInfoIPC) { + fileModeCallTimes_ += 1; int32_t checkResult = CheckAuthAndParam(customHapticInfoIPC.usage, customHapticInfoIPC.parameter, identifier); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); @@ -904,9 +921,90 @@ int32_t MiscdeviceService::PerformVibrationControl(const VibratorIdentifierIPC& return ERR_OK; } +void MiscdeviceService::ReportCallTimes() +{ + std::time_t now = std::time(nullptr); + std::tm *nowTm = std::localtime(&now); + if (nowTm == nullptr) { + MISC_HILOGE("Get the current time failed!"); + return; + } + int32_t hoursToMidnight = HOURS_IN_DAY - 1 - nowTm->tm_hour; + int32_t minutesToMidnight = MINUTES_IN_HOUR - 1 - nowTm->tm_min; + int32_t secondsToMidnight = SECONDS_IN_MINUTE - nowTm->tm_sec; + auto durationToMidnight = std::chrono::hours(hoursToMidnight) + std::chrono::minutes(minutesToMidnight) + + std::chrono::seconds(secondsToMidnight); + std::this_thread::sleep_for(durationToMidnight); + while (!stop_) { +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "VIBRATOR_MODES_STATISTICS", HiSysEvent::EventType::STATISTIC, + "TIME_MODE_CALL_TIMES", timeModeCallTimes_.load(), "PRESET_MODE_CALL_TIMES", presetModeCallTimes_.load(), + "FILE_MODE_CALL_TIMES", fileModeCallTimes_.load(), "PATTERN_MODE_CALL_TIMES", patternModeCallTimes_.load()); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + ReportInvalidVibratorIdCallTimes(); + MISC_HILOGI("CallTimesReport timeModeCallTimes:%{public}d, presetModeCallTimes:%{public}d, " + "fileModeCallTimes:%{public}d, patternModeCallTimes:%{public}d", + timeModeCallTimes_.load(), presetModeCallTimes_.load(), fileModeCallTimes_.load(), + patternModeCallTimes_.load()); + timeModeCallTimes_ = 0; + presetModeCallTimes_ = 0; + fileModeCallTimes_ = 0; + patternModeCallTimes_ = 0; + std::this_thread::sleep_for(std::chrono::hours(HOURS_IN_DAY)); + } +} + +void MiscdeviceService::SaveInvalidVibratorIdCallTimesInfo(const std::string &pageName, int32_t invalidVibratorId) +{ + std::lock_guard lock(invalidVibratorIdCallTimesMutex_); + if (invalidVibratorIdCallTimesMap_.find(pageName) != invalidVibratorIdCallTimesMap_.end()) { + std::map invalidMap = invalidVibratorIdCallTimesMap_[pageName]; + if (invalidMap.find(invalidVibratorId) != invalidMap.end()) { + invalidMap[invalidVibratorId] += 1; + } else { + invalidMap[invalidVibratorId] = 1; + } + invalidVibratorIdCallTimesMap_[pageName] = invalidMap; + } else { + std::map invalidMap; + invalidMap[invalidVibratorId] = 1; + invalidVibratorIdCallTimesMap_[pageName] = invalidMap; + } +} + +void MiscdeviceService::ReportInvalidVibratorIdCallTimes() +{ + std::lock_guard lock(invalidVibratorIdCallTimesMutex_); + if (invalidVibratorIdCallTimesMap_.empty()) { + MISC_HILOGI("invalidVibratorIdCallTimesMap_ empty"); + return; + } + for (const auto &item : invalidVibratorIdCallTimesMap_) { + std::string pageName = item.first; + std::map invalidMap = item.second; + if (invalidMap.empty()) { + continue; + } + int32_t maxCallTimes = 0; + int32_t maxCallTimesVibratorId = 0; + for (const auto &vibratorIdCallTimes : invalidMap) { + if (vibratorIdCallTimes.second > maxCallTimes) { + maxCallTimes = vibratorIdCallTimes.second; + maxCallTimesVibratorId = vibratorIdCallTimes.first; + } + } +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "INVALID_VIBRATOR_STATISTICS", HiSysEvent::EventType::STATISTIC, + "PKG_NAME", pageName, "INVALID_VIBRATOR_ID", maxCallTimesVibratorId, "CALL_TIMES", maxCallTimes); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + } + invalidVibratorIdCallTimesMap_.clear(); +} + int32_t MiscdeviceService::PlayPattern(const VibratorIdentifierIPC& identifier, const VibratePattern &pattern, const CustomHapticInfoIPC& customHapticInfoIPC) { + patternModeCallTimes_ += 1; int32_t checkResult = PlayPatternCheckAuthAndParam(customHapticInfoIPC.usage, customHapticInfoIPC.parameter); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); @@ -1274,6 +1372,7 @@ void MiscdeviceService::DestroyClientPid(const sptr &vibratorServ int32_t MiscdeviceService::PlayPrimitiveEffect(const VibratorIdentifierIPC& identifier, const std::string &effect, const PrimitiveEffectIPC& primitiveEffectIPC) { + presetModeCallTimes_ += 1; int32_t checkResult = PlayPrimitiveEffectCheckAuthAndParam(primitiveEffectIPC.intensity, primitiveEffectIPC.usage); if (checkResult != ERR_OK) { MISC_HILOGE("CheckAuthAndParam failed, ret:%{public}d", checkResult); @@ -1713,6 +1812,7 @@ bool MiscdeviceService::IsVibratorIdValid(const std::vector bas invalidVibratorIdCount_ = 0; MISC_HILOGE("VibratorId is not valid. package:%{public}s vibratorid:%{public}d", packageName.c_str(), target); } + SaveInvalidVibratorIdCallTimesInfo(packageName, target); return false; } diff --git a/services/miscdevice_service/src/vibration_priority_manager.cpp b/services/miscdevice_service/src/vibration_priority_manager.cpp index c10fa8c..df93dfb 100644 --- a/services/miscdevice_service/src/vibration_priority_manager.cpp +++ b/services/miscdevice_service/src/vibration_priority_manager.cpp @@ -71,9 +71,16 @@ const std::string SETTING_VIBRATE_INTENSITY_KEY = "vibration_intensity_index"; constexpr int32_t DECEM_BASE = 10; constexpr int32_t DATA_SHARE_READY = 0; constexpr int32_t DATA_SHARE_NOT_READY = 1055; +constexpr int32_t HOURS_IN_DAY = 24; +constexpr int32_t MINUTES_IN_HOUR = 60; +constexpr int32_t SECONDS_IN_MINUTE = 60; } // namespace -VibrationPriorityManager::VibrationPriorityManager() {} +std::atomic_bool VibrationPriorityManager::stop_ = false; + +VibrationPriorityManager::VibrationPriorityManager() + : reportSwitchStatusThread_([this]() { this->ReportSwitchStatus(); }) +{} VibrationPriorityManager::~VibrationPriorityManager() { @@ -86,6 +93,10 @@ VibrationPriorityManager::~VibrationPriorityManager() MISC_HILOGE("UnregisterUserObserver failed"); } #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB + if (reportSwitchStatusThread_.joinable()) { + stop_ = true; + reportSwitchStatusThread_.join(); + } } bool VibrationPriorityManager::Init() @@ -465,13 +476,20 @@ void VibrationPriorityManager::MiscCrownIntensityFeedbackInit(void) MISC_HILOGE("Get crownfeedback failed"); } miscCrownFeedback_ = crownfeedback; - +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, "SWITCH_TYPE", + "crownfeedback", "STATUS", crownfeedback); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE int32_t intensity = miscIntensity_; if (GetIntValue(SETTING_VIBRATE_INTENSITY_KEY, intensity) != ERR_OK) { intensity = FEEDBACK_INTENSITY_STRONGE; MISC_HILOGE("Get intensity failed"); } miscIntensity_ = intensity; +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, "SWITCH_TYPE", + "intensity", "STATUS", intensity); +#endif // HIVIEWDFX_HISYSEVENT_ENABLE } bool VibrationPriorityManager::ShouldIgnoreByIntensity(const VibrateInfo &vibrateInfo) @@ -621,6 +639,47 @@ bool VibrationPriorityManager::IsSystemCalling() return Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(IPCSkeleton::GetCallingFullTokenID()); } +void VibrationPriorityManager::ReportSwitchStatus() +{ + std::time_t now = std::time(nullptr); + std::tm *nowTm = std::localtime(&now); + if (nowTm == nullptr) { + MISC_HILOGE("Get the current time failed!"); + return; + } + int32_t hoursToMidnight = HOURS_IN_DAY - 1 - nowTm->tm_hour; + int32_t minutesToMidnight = MINUTES_IN_HOUR - 1 - nowTm->tm_min; + int32_t secondsToMidnight = SECONDS_IN_MINUTE - nowTm->tm_sec; + auto durationToMidnight = std::chrono::hours(hoursToMidnight) + std::chrono::minutes(minutesToMidnight) + + std::chrono::seconds(secondsToMidnight); + std::this_thread::sleep_for(durationToMidnight); + while (!stop_) { + int32_t feedbackTemp = miscFeedback_; + int32_t ringModeTemp = miscAudioRingerMode_; +#ifdef HIVIEWDFX_HISYSEVENT_ENABLE + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, + "SWITCH_TYPE", "feedbackCurrentStatus", "STATUS", feedbackTemp); + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, + "SWITCH_TYPE", "ringerModeCurrentStatus", "STATUS", ringModeTemp); +#ifdef OHOS_BUILD_ENABLE_VIBRATOR_CROWN + int32_t crownfeedback = miscCrownFeedback_; + int32_t intensity = miscIntensity_; + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, + "SWITCH_TYPE", "crownfeedback", "STATUS", crownfeedback); + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, + "SWITCH_TYPE", "intensity", "STATUS", intensity); +#endif // OHOS_BUILD_ENABLE_VIBRATOR_CROWN +#ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB + int32_t currentDoNotDisturbSwitch = doNotDisturbSwitch_; + HiSysEventWrite(HiSysEvent::Domain::MISCDEVICE, "SWITCHES_TOGGLE", HiSysEvent::EventType::BEHAVIOR, + "SWITCH_TYPE", "currentDoNotDisturbSwitch", "STATUS", currentDoNotDisturbSwitch); +#endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB +#endif // HIVIEWDFX_HISYSEVENT_ENABLE + MISC_HILOGI("feedbackCurrentStatus:%{public}d, ringerModeCurrentStatus:%{public}d", feedbackTemp, ringModeTemp); + std::this_thread::sleep_for(std::chrono::hours(HOURS_IN_DAY)); + } +} + #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD bool VibrationPriorityManager::ShouldIgnoreInputMethod(const VibrateInfo &vibrateInfo) { -- Gitee