1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_ANS_CORE_INCLUDE_REMINDER_DATA_MANAGER_H 17 #define BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_ANS_CORE_INCLUDE_REMINDER_DATA_MANAGER_H 18 19 #include <map> 20 #include <vector> 21 22 #include "advanced_notification_service.h" 23 #include "ans_inner_errors.h" 24 #ifdef PLAYER_FRAMEWORK_ENABLE 25 #include "player.h" 26 #endif 27 #include "ffrt.h" 28 #include "app_mgr_client.h" 29 #include "reminder_request.h" 30 #include "reminder_store.h" 31 #include "reminder_timer_info.h" 32 #include "reminder_config_change_observer.h" 33 #include "datashare_predicates.h" 34 #include "datashare_values_bucket.h" 35 #include "app_mgr_interface.h" 36 #include "time_service_client.h" 37 38 namespace OHOS { 39 namespace Notification { 40 class ReminderDataManager final { 41 public: ReminderDataManager()42 ReminderDataManager() 43 { 44 Init(false); 45 }; 46 ~ReminderDataManager(); 47 48 ReminderDataManager(ReminderDataManager &other) = delete; 49 ReminderDataManager& operator = (const ReminderDataManager &other) = delete; 50 51 /** 52 * @brief Cancels all the reminders relative to the bundle option. 53 * 54 * @param packageName Indicates the package name. 55 * @param userId Indicates the user id which the bundle belong to. 56 * @return ERR_OK if success, else not. 57 */ 58 ErrCode CancelAllReminders(const std::string &packageName, const int32_t &userId); 59 60 /** 61 * @brief Cancels the target reminder relative to the reminder id and bundle option. 62 * 63 * @param reminderId Indicates the reminder id. 64 * @param bundleOption Indicates the bundle option. 65 * @return ERR_OK if success, else not. 66 */ 67 ErrCode CancelReminder(const int32_t &reminderId, const sptr<NotificationBundleOption> &bundleOption); 68 69 /** 70 * @brief Close the target reminder which is showing on panel. 71 * This is manul operation by user: 1.Click close button of the reminder, 2.remove reminder notification. 72 * 73 * @param want Want information that transferred when the event trigger by user. 74 * @param cancelNotification Indicates whether need to cancel notification or not. 75 */ 76 void CloseReminder(const OHOS::EventFwk::Want &want, bool cancelNotification); 77 78 /** 79 * Dump all the reminders information. 80 * 81 * @return reminders informations. 82 */ 83 std::string Dump() const; 84 85 /** 86 * Obtains the single instance. 87 * 88 * @return Single instance of ReminderDataManager. 89 */ 90 static std::shared_ptr<ReminderDataManager> GetInstance(); 91 static std::shared_ptr<ReminderDataManager> InitInstance( 92 const sptr<AdvancedNotificationService> &advancedNotificationService); 93 94 /** 95 * Obtains all the valid reminders (which are not expired) relative to the bundle option. 96 * 97 * @param bundleOption Indicates the bundle option. 98 * @param[out] reminders return the valid reminders. 99 */ 100 void GetValidReminders( 101 const sptr<NotificationBundleOption> &bundleOption, std::vector<sptr<ReminderRequest>> &reminders); 102 103 /** 104 * @brief Inits and recovery data from database. 105 * 106 * @param isFromBootComplete Indicates the init is called when boot completed. 107 */ 108 void Init(bool isFromBootComplete); 109 110 void InitUserId(); 111 112 /** 113 * @brief Register configuration observer, the listening system language is changed. 114 */ 115 bool RegisterConfigurationObserver(); 116 117 void OnUserRemove(const int32_t& userId); 118 119 void OnServiceStart(); 120 121 void OnUserSwitch(const int32_t& userId); 122 123 /** 124 * @brief Triggered when third party application died. 125 * 126 * @param bundleOption Indicates the bundleOption of third party application. 127 */ 128 void OnProcessDiedLocked(const sptr<NotificationBundleOption> &bundleOption); 129 130 /** 131 * Publishs a scheduled reminder. 132 * 133 * @param reminder Indicates the reminder. 134 * @param bundleOption Indicates bundle option the reminder belongs to. 135 * @return ERR_OK if success, else not. 136 */ 137 ErrCode PublishReminder(const sptr<ReminderRequest> &reminder, 138 const sptr<NotificationBundleOption> &bundleOption); 139 140 /** 141 * @brief Refresh all reminders when date/time or timeZone of device changed by user. 142 * 143 * @param type Indicates it is triggered by dateTime change or timeZone change. 144 */ 145 void RefreshRemindersDueToSysTimeChange(uint8_t type); 146 147 /** 148 * @brief Indicates the single instance of ans that used to execute operations in service. 149 * 150 * @param Indicates the single instance of ans notification service. 151 */ 152 void SetService(sptr<AdvancedNotificationService> &advancedNotificationService); 153 154 bool ShouldAlert(const sptr<ReminderRequest> &reminder) const; 155 156 /** 157 * @brief Show the reminder. 158 * 159 * @param isSysTimeChanged Indicates it is triggered as dateTime changed by user or not. 160 * @param want Which contains the given reminder. 161 */ 162 void ShowActiveReminder(const EventFwk::Want &want); 163 164 /** 165 * @brief Snooze the reminder by manual. 166 * 1) Snooze the trigger time to the next. 167 * 2) Update the notification(Update notification lable/content...; Stop audio player and vibrator) 168 * 3) Show the notification dialog in the SystemUI 169 * 4) Start a new reminder, which is recent one now. 170 * 171 * @param want Which contains the given reminder. 172 */ 173 void SnoozeReminder(const OHOS::EventFwk::Want &want); 174 175 /** 176 * Starts the recent reminder timing. 177 */ 178 void StartRecentReminder(); 179 180 /** 181 * Handle custom button click event. 182 */ 183 void HandleCustomButtonClick(const OHOS::EventFwk::Want &want); 184 185 /** 186 * @brief Terminate the alerting reminder. 187 * 188 * 1. Stop sound and vibrate. 189 * 2. Stop the alerting timer. 190 * 3. Update the reminder state. 191 * 4. Update the display content of the notification. 192 * 193 * @param want Which contains the given reminder. 194 */ 195 void TerminateAlerting(const OHOS::EventFwk::Want &want); 196 197 /** 198 * @brief Get resource manager by handle info. 199 */ 200 std::shared_ptr<Global::Resource::ResourceManager> GetBundleResMgr( 201 const AppExecFwk::BundleInfo &bundleInfo); 202 203 /** 204 * @brief Update reminders based on the system language. 205 * 206 * Update action button title. 207 */ 208 void UpdateReminderLanguage(const sptr<ReminderRequest> &reminder); 209 void UpdateReminderLanguageLocked(const sptr<ReminderRequest> &reminder); 210 211 /** 212 * @brief System language change 213 */ 214 void OnConfigurationChanged(const AppExecFwk::Configuration &configuration); 215 216 /** 217 * @brief When OnRemoveSystemAbility occurs. 218 */ 219 void OnRemoveAppMgr(); 220 221 static const uint8_t TIME_ZONE_CHANGE; 222 static const uint8_t DATE_TIME_CHANGE; 223 224 private: 225 enum class TimerType : uint8_t { 226 TRIGGER_TIMER, 227 ALERTING_TIMER 228 }; 229 230 /** 231 * Add default slot to the reminder if no slot set by user. 232 * 233 * @param reminder Indicates the reminder. 234 */ 235 void AddDefaultSlotIfNeeded(sptr<ReminderRequest> &reminder); 236 237 /** 238 * Add reminder to showed reminder vector. 239 * 240 * @param reminder Indicates the showed reminder. 241 */ 242 void AddToShowedReminders(const sptr<ReminderRequest> &reminder); 243 244 void CancelAllReminders(const int32_t &userId); 245 246 /** 247 * @brief Check the update conditions. 248 * 249 * @param reminder Indicates the showed reminder. 250 * @param actionButtonType Button type of the button. 251 * @param actionButtonMap Button map. 252 * @return True if check successful. 253 */ 254 bool CheckUpdateConditions(const sptr<ReminderRequest> &reminder, 255 const ReminderRequest::ActionButtonType &actionButtonType, 256 const std::map<ReminderRequest::ActionButtonType, ReminderRequest::ActionButtonInfo> &actionButtonMap); 257 258 /** 259 * @brief update app database. 260 * 261 * @param reminder Indicates the showed reminder. 262 * @param actionButtonType Button type of the button. 263 */ 264 void UpdateAppDatabase(const sptr<ReminderRequest> &reminder, 265 const ReminderRequest::ActionButtonType &actionButtonType); 266 267 /** 268 * @brief generate Predicates for dataShare. 269 * 270 * @param predicates find fields from database. 271 * @param equalToVector Split from dataShareUpdate->equaleTo. 272 */ 273 void GenPredicates(DataShare::DataSharePredicates &predicates, const std::vector<std::string> &equalToVector); 274 275 /** 276 * @brief generate ValuesBucket for dataShare. 277 * 278 * @param valuesBucket update fields at database. 279 * @param valuesBucketVector Split from dataShareUpdate->valuesBucket. 280 */ 281 void GenValuesBucket(DataShare::DataShareValuesBucket &valuesBucket, 282 const std::vector<std::string> &valuesBucketVector); 283 284 /** 285 * @brief get bundleName from uri. 286 * 287 * @param dstBundleName The package name required to update the database. 288 * @param uri Database address. 289 */ 290 void GenDstBundleName(std::string &dstBundleName, const std::string &uri) const; 291 292 /** 293 * @brief get custom ring uri. 294 * 295 * @param reminder Indicates the reminder. 296 * @return Returns the uri of ring tone. 297 */ 298 std::string GetCustomRingUri(const sptr<ReminderRequest> &reminder); 299 300 /** 301 * @brief Cancels all the reminders of the target bundle or user. 302 * 303 * @param packageName Indicates the packageName need to cancel. 304 * @param userId Indicates the userId to cancel. 305 */ 306 void CancelRemindersImplLocked(const std::string &packageName, const int32_t &userId); 307 308 /** 309 * @brief Close reminders with the same group id. 310 * 311 * @param oldReminderId Indicates the reminderId that are currently bing showed. 312 * @param packageName Indicates the packageName need to cancel. 313 * @param groupId Indicates the group id to cancel. 314 */ 315 void CloseRemindersByGroupId(const int32_t &oldReminderId, const std::string &packageName, 316 const std::string &groupId); 317 318 /** 319 * Cancels the notification relative to the reminder. 320 * 321 * @param reminder Indicates the reminder. 322 */ 323 void CancelNotification(const sptr<ReminderRequest> &reminder) const; 324 325 /** 326 * Check whether the number limit of reminders if exceeded. 327 * 328 * @param bundleName Indicates the target bundle. 329 * @return true if number limit is exceeded. 330 */ 331 bool CheckReminderLimitExceededLocked(const sptr<NotificationBundleOption> &bundleOption, 332 const sptr<ReminderRequest> &reminder) const; 333 void CloseReminder(const sptr<ReminderRequest> &reminder, bool cancelNotification); 334 335 /** 336 * Create a information for timer, such as timer type, repeat policy, interval and want agent. 337 * 338 * @param type Indicates the timer type. 339 * @param reminderRequest Indicates the reminder request. 340 * @return pointer of ReminderTimerInfo. 341 */ 342 std::shared_ptr<ReminderTimerInfo> CreateTimerInfo(TimerType type, 343 const sptr<ReminderRequest> &reminderRequest) const; 344 void InitTimerInfo(std::shared_ptr<ReminderTimerInfo> &timerInfo, 345 const sptr<ReminderRequest> &reminderRequest, TimerType reminderType) const; 346 347 void GetImmediatelyShowRemindersLocked(std::vector<sptr<ReminderRequest>> &reminders) const; 348 349 std::string GetSoundUri(const sptr<ReminderRequest> &reminder); 350 351 /** 352 * Find the reminder from reminderVector_ by reminder id. 353 * 354 * @param reminderId Indicates the reminder id. 355 * @return pointer of reminder request or nullptr. 356 */ 357 sptr<ReminderRequest> FindReminderRequestLocked(const int32_t &reminderId); 358 359 /** 360 * Find the reminder from {@link reminderVector_} and 361 * {@link notificationBundleOptionMap_} by reminder id and pkgName. 362 * 363 * @param reminderId Indicates the reminder id. 364 * @param pkgName Indicates the package name. 365 * @return pointer of reminder request or nullptr. 366 */ 367 sptr<ReminderRequest> FindReminderRequestLocked(const int32_t &reminderId, const std::string &pkgName); 368 369 /** 370 * Find bundle option from {@link notificationBundleOptionMap_} by reminder id. 371 * 372 * @param reminderId Indicates the reminder id. 373 * @return pointer of NotificationBundleOption or nullptr. 374 */ 375 sptr<NotificationBundleOption> FindNotificationBundleOption(const int32_t &reminderId) const; 376 377 /** 378 * Obtains the recent reminder which is not expired from reminder vector. 379 * 380 * The expired reminders will be removed from reminderVector_ and notificationBundleOptionMap_. 381 * 382 * @return pointer of reminder object. 383 */ 384 sptr<ReminderRequest> GetRecentReminderLocked(); 385 386 void HandleImmediatelyShow(std::vector<sptr<ReminderRequest>> &showImmediately, bool isSysTimeChanged); 387 388 /** 389 * @brief Refresh the reminder due to date/time or timeZone change by user. 390 * 391 * @param type Indicates it is date/time change or timeZone change. 392 * @param reminder Indicates the target reminder. 393 * @return sptr<ReminderRequest> Returns the target reminder if it is need to show immediately, otherwise nullptr. 394 */ 395 sptr<ReminderRequest> HandleRefreshReminder(const uint8_t &type, sptr<ReminderRequest> &reminder); 396 397 /** 398 * @brief Handles all the reminders that have the same notification id and belong to same application 399 * with the current reminder. Unset the state of "showing". 400 * 401 * @param reminder Indicates the current reminder. 402 */ 403 void HandleSameNotificationIdShowing(const sptr<ReminderRequest> reminder); 404 405 bool HandleSysTimeChange(const sptr<ReminderRequest> reminder) const; 406 407 /** 408 * @brief Judge the two reminders is belong to the same application or not. 409 * 410 * @param bundleOption Indicates the bundleOption of first reminder. 411 * @param other Indicates the bundleOption of second reminder. 412 * @return true if the two reminders belong to the same application. 413 */ 414 bool IsBelongToSameApp(const sptr<NotificationBundleOption> &bundleOption, 415 const sptr<NotificationBundleOption> &other) const; 416 417 /** 418 * @brief Judges whether the reminder is matched with the bundleOption or userId. 419 * 420 * @param reminder Indicates the target reminder. 421 * @param packageName Indicates the package name. 422 * @param userId Indicates the user id. 423 * @return true If the reminder is matched with the bundleOption or userId. 424 */ 425 bool IsMatched(const sptr<ReminderRequest> &reminder, const std::string &packageName, const int32_t &userId) const; 426 427 /** 428 * @brief Judges whether the reminder is matched with the packageName or groupId. 429 * 430 * @param reminder Indicates the target reminder. 431 * @param packageName Indicates the package name. 432 * @param groupId Indicates the group id. 433 * @return true If the reminder is matched with the packageName and groupId. 434 */ 435 bool IsMatchedForGroupIdAndPkgName(const sptr<ReminderRequest> &reminder, const std::string &packageName, 436 const std::string &groupId) const; 437 438 bool IsAllowedNotify(const sptr<ReminderRequest> &reminder) const; 439 440 bool IsReminderAgentReady() const; 441 442 void LoadReminderFromDb(); 443 444 void PlaySoundAndVibrationLocked(const sptr<ReminderRequest> &reminder); 445 void PlaySoundAndVibration(const sptr<ReminderRequest> &reminder); 446 void StopSoundAndVibrationLocked(const sptr<ReminderRequest> &reminder); 447 void StopSoundAndVibration(const sptr<ReminderRequest> &reminder); 448 449 /** 450 * Remove from showed reminder vector. 451 * 452 * @param reminder Indicates the reminder need to remove. 453 */ 454 void RemoveFromShowedReminders(const sptr<ReminderRequest> &reminder); 455 456 /** 457 * @brief Refresh the all reminders due to date/time or timeZone change by user. 458 * 459 * @param type Indicates it is date/time change or timeZone change. 460 * @return reminders that need to show immediately. 461 */ 462 std::vector<sptr<ReminderRequest>> RefreshRemindersLocked(uint8_t type); 463 464 /** 465 * Removes the reminder. 466 * 1. removes the reminder from reminderVector_ and notificationBundleOptionMap_. 467 * 2. cancels the notification. 468 * 469 * @param reminderId Indicates the reminder id. 470 */ 471 void RemoveReminderLocked(const int32_t &reminderId); 472 473 /** 474 * Resets timer status. 475 * 1. Sets timerId_ or timerIdAlerting_ with 0. 476 * 2. Sets activeReminderId_ or alertingReminderId with -1. 477 * 478 * @param type Indicates the timer type. 479 */ 480 void ResetStates(TimerType type); 481 482 void SetActiveReminder(const sptr<ReminderRequest> &reminder); 483 void SetAlertingReminder(const sptr<ReminderRequest> &reminder); 484 void ShowActiveReminderExtendLocked(sptr<ReminderRequest> &reminder); 485 486 /** 487 * @brief Show the reminder on SystemUI. 488 * 489 * @param reminder Indicates the reminder to show. 490 * @param isNeedToPlaySound Indicates whether need to play sound. 491 * @param isNeedToStartNext Indicates whether need to start next reminder. 492 * @param isSysTimeChanged Indicates whether it is triggerred as system time changed by user. 493 * @param needScheduleTimeout Indicates whether need to control the ring duration. 494 */ 495 void ShowReminder(const sptr<ReminderRequest> &reminder, const bool &isNeedToPlaySound, 496 const bool &isNeedToStartNext, const bool &isSysTimeChanged, const bool &needScheduleTimeout); 497 498 void SnoozeReminderImpl(sptr<ReminderRequest> &reminder); 499 500 /** 501 * Starts timing actually. 502 * 503 * @param reminderRequest Indicates the reminder. 504 * @param type Indicates the timer type. 505 */ 506 void StartTimerLocked(const sptr<ReminderRequest> &reminderRequest, TimerType type); 507 void StartTimer(const sptr<ReminderRequest> &reminderRequest, TimerType type); 508 509 uint64_t HandleTriggerTimeInner(const sptr<ReminderRequest> &reminderRequest, TimerType type, 510 const sptr<MiscServices::TimeServiceClient> &timer); 511 512 uint64_t HandleAlertingTimeInner(const sptr<ReminderRequest> &reminderRequest, TimerType type, 513 const sptr<MiscServices::TimeServiceClient> &timer, time_t now); 514 515 /** 516 * @brief Stop the alerting timer and update reminder information. 517 * 518 * 1. Stop sound and vibrate. 519 * 2. Stop the alerting timer. 520 * 521 * @param reminder Indicates the target reminder. 522 */ 523 void StopAlertingReminder(const sptr<ReminderRequest> &reminder); 524 525 /** 526 * Stops timing. 527 * 528 * @param type Indicates the timer type. 529 */ 530 void StopTimer(TimerType type); 531 void StopTimerLocked(TimerType type); 532 533 /** 534 * @brief Terminate the alerting reminder. 535 * 536 * 1. Stop sound and vibrate. 537 * 2. Stop the alerting timer. 538 * 3. Update the reminder state. 539 * 4. Update the display content of the notification. 540 * 541 * @param reminder Indicates the reminder. 542 * @param reason Indicates the description information. 543 */ 544 void TerminateAlerting(const sptr<ReminderRequest> &reminder, const std::string &reason); 545 void TerminateAlerting(const uint16_t waitInSecond, const sptr<ReminderRequest> &reminder); 546 547 /** 548 * @brief Assign unique reminder id and save reminder in memory. 549 * 550 * @param reminder Indicates a reminder. 551 * @param bundleOption Indicates bundle option relative to the reminder. 552 */ 553 void UpdateAndSaveReminderLocked( 554 const sptr<ReminderRequest> &reminder, const sptr<NotificationBundleOption> &bundleOption); 555 556 void UpdateNotification(const sptr<ReminderRequest> &reminder, bool isSnooze); 557 558 static bool cmp(sptr<ReminderRequest> &reminderRequest, sptr<ReminderRequest> &other); 559 560 /** 561 * @brief Connect App Manager to get the current foreground application. 562 */ 563 bool ConnectAppMgr(); 564 565 /** 566 * @brief Check need to notify the application, if the current foreground application 567 * is the creator of the reminder, notify the application of the reminder status 568 * change; otherwise, do not noitfy. 569 * 570 * @param reminder Indicates a reminder. 571 * @param buttonType The type of button clicked by the user. 572 */ 573 void CheckNeedNotifyStatus(const sptr<ReminderRequest> &reminder, 574 const ReminderRequest::ActionButtonType buttonType); 575 576 /** 577 * Single instance. 578 */ 579 static std::shared_ptr<ReminderDataManager> REMINDER_DATA_MANAGER; 580 581 /** 582 * Used for multi-thread synchronise. 583 */ 584 static std::mutex MUTEX; 585 static std::mutex SHOW_MUTEX; 586 static std::mutex ALERT_MUTEX; 587 static std::mutex TIMER_MUTEX; 588 589 /** 590 * Max number of reminders limit for the whole system. 591 */ 592 static const int16_t MAX_NUM_REMINDER_LIMIT_SYSTEM; 593 594 /** 595 * Max number of reminders limit for one system application. 596 */ 597 static const int16_t MAX_NUM_REMINDER_LIMIT_SYS_APP; 598 599 /** 600 * Max number of reminders limit for one application. 601 */ 602 static const int16_t MAX_NUM_REMINDER_LIMIT_APP; 603 604 bool isReminderAgentReady_ = false; 605 606 /** 607 * Vector used to record all the reminders in system. 608 */ 609 std::vector<sptr<ReminderRequest>> reminderVector_; 610 611 /** 612 * Vector used to record all the reminders which has been shown on panel. 613 */ 614 std::vector<sptr<ReminderRequest>> showedReminderVector_; 615 616 /** 617 * Map used to record all the bundle information of the reminders in system. 618 */ 619 std::map<int32_t, sptr<NotificationBundleOption>> notificationBundleOptionMap_; 620 621 /** 622 * This timer is used to control the triggerTime of next reminder. 623 */ 624 uint64_t timerId_ {0}; 625 626 /** 627 * This timer is used to control the ringDuration of the alerting reminder. 628 */ 629 uint64_t timerIdAlerting_ {0}; 630 631 /** 632 * Indicates the active reminder that timing is taking effect. 633 */ 634 int32_t activeReminderId_ = -1; 635 sptr<ReminderRequest> activeReminder_ = nullptr; 636 637 /** 638 * Indicates the reminder which is playing sound or vibration. 639 */ 640 int32_t alertingReminderId_ = -1; 641 sptr<ReminderRequest> alertingReminder_ = nullptr; 642 #ifdef PLAYER_FRAMEWORK_ENABLE 643 std::shared_ptr<Media::Player> soundPlayer_ = nullptr; 644 #endif 645 /** 646 * Indicates the total count of reminders in system. 647 */ 648 int16_t totalCount_ {0}; 649 int currentUserId_ {0}; 650 sptr<AdvancedNotificationService> advancedNotificationService_ = nullptr; 651 std::shared_ptr<ReminderStore> store_ = nullptr; 652 653 /** 654 * Indicates config change observer for language 655 */ 656 sptr<AppExecFwk::IConfigurationObserver> configChangeObserver_ = nullptr; 657 658 /** 659 * Indicates app mananger for get foreground application 660 */ 661 std::mutex appMgrMutex_; 662 sptr<AppExecFwk::IAppMgr> appMgrProxy_ = nullptr; 663 664 /** 665 * async queue 666 */ 667 std::shared_ptr<ffrt::queue> queue_ = nullptr; 668 }; 669 } // namespace OHOS 670 } // namespace Notification 671 #endif // BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_ANS_CORE_INCLUDE_REMINDER_DATA_MANAGER_H 672