diff --git a/frameworks/reminder_ani/BUILD.gn b/frameworks/reminder_ani/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..644aaa45b8073863684c73dffa13df427f75b78d --- /dev/null +++ b/frameworks/reminder_ani/BUILD.gn @@ -0,0 +1,96 @@ +# 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. + +import("//base/notification/distributed_notification_service/notification.gni") +import("//build/ohos.gni") +import("//build/ohos/taihe_idl/taihe.gni") +import("//build/config/components/ets_frontend/ets2abc_config.gni") + +taihe_generated_file_path = "${taihe_file_path}/out/${subsystem_name}/${component_name}" + +copy_taihe_idl("copy_reminder_agent_manager") { + sources = [ + "idl/ohos.reminderAgentManager.manager.taihe", + "idl/ohos.reminderAgentManager.taihe", + ] +} + +ohos_taihe("run_taihe") { + taihe_generated_file_path = "${taihe_generated_file_path}" + deps = [ ":copy_reminder_agent_manager" ] + outputs = [ + "${taihe_generated_file_path}/src/ohos.reminderAgentManager.manager.ani.cpp", + "${taihe_generated_file_path}/src/ohos.reminderAgentManager.manager.abi.c", + ] +} + +taihe_shared_library("reminder_agent_manager_ani") { + branch_protector_ret = "pac_ret" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + + taihe_generated_file_path = "${taihe_generated_file_path}" + subsystem_name = "${subsystem_name}" + part_name = "${component_name}" + + include_dirs = [ + "include", + ] + sources = get_target_outputs(":run_taihe") + sources += [ + "src/ani_constructor.cpp", + "src/ohos.reminderAgentManager.impl.cpp", + "src/reminder_ani_common.cpp", + ] + + deps = [ + ":run_taihe", + "${frameworks_module_reminder_path}:reminder_innerkits", + "${frameworks_module_ans_path}:ans_innerkits", + "${frameworks_path}/ets/ani:notification_manager_ani", + ] + + external_deps = [ + "ability_base:zuri", + "c_utils:utils", + "hilog:libhilog", + ] +} + +generate_static_abc("reminder_agent_manager_abc") { + base_url = "${taihe_generated_file_path}" + files = [ "${taihe_generated_file_path}/@ohos.reminderAgentManager.ets" ] + is_boot_abc = "True" + device_dst_file = "/system/framework/reminder_agent_manager_abc.abc" + dependencies = [ ":run_taihe" ] +} + +ohos_prebuilt_etc("reminder_agent_manager_etc") { + source = "${target_out_dir}/reminder_agent_manager_abc.abc" + module_install_dir = "framework" + part_name = "${component_name}" + subsystem_name = "${subsystem_name}" + deps = [ + ":reminder_agent_manager_abc", + ] +} + +group("reminder_agent_manager_taihe") { + deps = [ + ":reminder_agent_manager_ani", + ":reminder_agent_manager_etc", + ] +} \ No newline at end of file diff --git a/frameworks/reminder_ani/idl/ohos.reminderAgentManager.manager.taihe b/frameworks/reminder_ani/idl/ohos.reminderAgentManager.manager.taihe new file mode 100644 index 0000000000000000000000000000000000000000..68d3eab754b2762d342cb892c5bde1e29e81c7e3 --- /dev/null +++ b/frameworks/reminder_ani/idl/ohos.reminderAgentManager.manager.taihe @@ -0,0 +1,174 @@ +/* + * 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. + */ + +@!namespace("@ohos.reminderAgentManager", "reminderAgentManager") + +@!sts_inject(""" +static { loadLibrary("reminder_agent_manager_ani.z"); } +""") + +enum ReminderType: i32 { + REMINDER_TYPE_TIMER = 0, + REMINDER_TYPE_CALENDAR = 1, + REMINDER_TYPE_ALARM = 2, +} + +enum ActionButtonType: i32 { + ACTION_BUTTON_TYPE_CLOSE = 0, + ACTION_BUTTON_TYPE_SNOOZE = 1, + ACTION_BUTTON_TYPE_CUSTOM = 2, +} + +union DataShareUpdateRecord { + s: String; + d: f64; + n: i32; + b: bool; +} + +struct DataShareUpdate { + uri: String; + equalTo: @record Map; + value: @sts_type("ValuesBucket") Opaque; +} + +struct WantAgent { + pkgName: String; + abilityName: String; + uri: Optional; + parameters: Optional<@record Map>; +} + +struct MaxScreenWantAgent { + pkgName: String; + abilityName: String; +} + +struct ActionButton { + title: String; + titleResource: Optional; + type: ActionButtonType; + wantAgent: Optional; + dataShareUpdate: Optional; +} + +struct LocalDateTime { + year: i32; + month: i32; + day: i32; + hour: i32; + minute: i32; + second: Optional; +} + +struct ReminderRequest { + reminderType: ReminderType; + actionButton: Optional>; + wantAgent: Optional; + maxScreenWantAgent: Optional; + ringDuration: Optional; + snoozeTimes: Optional; + timeInterval: Optional; + title: Optional; + titleResourceId: Optional; + content: Optional; + contentResourceId: Optional; + expiredContent: Optional; + expiredContentResourceId: Optional; + snoozeContent: Optional; + snoozeContentResourceId: Optional; + notificationId: Optional; + groupId: Optional; + slotType: Optional<@sts_type("notification.SlotType") Opaque>; + tapDismissed: Optional; + autoDeletedTime: Optional; + snoozeSlotType: Optional<@sts_type("notification.SlotType") Opaque>; + customRingUri: Optional; +} + +@class +struct ReminderRequestCalendar { + @extends base: ReminderRequest; + dateTime: LocalDateTime; + repeatMonths: Optional>; + repeatDays: Optional>; + daysOfWeek: Optional>; + endDateTime: Optional; + rruleWantAgent: Optional; +} + +@class +struct ReminderRequestAlarm { + @extends base: ReminderRequest; + hour: i32; + minute: i32; + daysOfWeek: Optional>; +} + +@class +struct ReminderRequestTimer { + @extends base: ReminderRequest; + triggerTimeInSeconds: u64; +} + +union ParamReminder { + timer: ReminderRequestTimer; + alarm: ReminderRequestAlarm; + calendar: ReminderRequestCalendar; +} + +struct ReminderInfo { + reminderId: i32; + reminderReq: ParamReminder; +} + +@gen_async("publishReminder") +@gen_promise("publishReminder") +function PublishReminderSync(reminderReq: ParamReminder): i32; + +@gen_async("cancelReminder") +@gen_promise("cancelReminder") +function CancelReminderSync(reminderId: i32): void; + +@gen_async("getValidReminders") +@gen_promise("getValidReminders") +function GetValidRemindersSync(): Array; + +@gen_async("cancelAllReminders") +@gen_promise("cancelAllReminders") +function CancelAllRemindersSync(): void; + +@gen_async("addNotificationSlot") +@gen_promise("addNotificationSlot") +function AddNotificationSlotSync(slot: @sts_type("NotificationSlot") Opaque): void; + +@gen_async("removeNotificationSlot") +@gen_promise("removeNotificationSlot") +function RemoveNotificationSlotSync(slotType: @sts_type("notification.SlotType") Opaque): void; + +@gen_promise("addExcludeDate") +function AddExcludeDateSync(reminderId: i32, date: u64): void; + +@gen_promise("deleteExcludeDates") +function DeleteExcludeDatesSync(reminderId: i32): void; + +@gen_promise("getExcludeDates") +function GetExcludeDatesSync(reminderId: i32): Array; + +@gen_promise("getAllValidReminders") +function GetAllValidRemindersSync(): Array; + +@gen_promise("updateReminder") +function UpdateReminderSync(reminderId: i32, reminderReq: ParamReminder): void; diff --git a/frameworks/reminder_ani/idl/ohos.reminderAgentManager.taihe b/frameworks/reminder_ani/idl/ohos.reminderAgentManager.taihe new file mode 100644 index 0000000000000000000000000000000000000000..b3cbbd10640b8fc793cc97a38f3b4a1700cda248 --- /dev/null +++ b/frameworks/reminder_ani/idl/ohos.reminderAgentManager.taihe @@ -0,0 +1,22 @@ +/* + * 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. + */ + +@!namespace("@ohos.reminderAgentManager") + +@!sts_inject(""" +import type notification from '@ohos.notificationManager'; +import type { NotificationSlot } from 'notification.notificationSlot'; +import type { ValuesBucket } from '@ohos.data.ValuesBucket'; +""") diff --git a/frameworks/reminder_ani/include/reminder_ani_common.h b/frameworks/reminder_ani/include/reminder_ani_common.h new file mode 100644 index 0000000000000000000000000000000000000000..b0d72382b88c3d04c1a8142bdc6ed80298d63752 --- /dev/null +++ b/frameworks/reminder_ani/include/reminder_ani_common.h @@ -0,0 +1,71 @@ +/* + * 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 BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_REMINDER_ANI_INCLUDE_REMINDER_ANI_COMMON_H +#define BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_REMINDER_ANI_INCLUDE_REMINDER_ANI_COMMON_H + +#include "ohos.reminderAgentManager.manager.proj.hpp" + +#include "reminder_request.h" + +namespace OHOS::ReminderAgentManagerNapi { +class Common { +public: + enum ErrorCode : int32_t { + ERR_REMINDER_PERMISSION_DENIED = 201, + ERR_REMINDER_INVALID_PARAM = 401, + ERR_REMINDER_NOTIFICATION_NOT_ENABLE = 1700001, + ERR_REMINDER_NUMBER_OVERLOAD, + ERR_REMINDER_NOT_EXIST, + ERR_REMINDER_PACKAGE_NOT_EXIST, + ERR_REMINDER_CALLER_TOKEN_INVALID, + ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED, + }; + + static std::string getErrCodeMsg(const int32_t errorCode); + + static bool CreateReminder(const ::ohos::reminderAgentManager::manager::ParamReminder& reminderReq, + std::shared_ptr& reminder); + +private: + static bool ParseIntArray(const ::taihe::array& values, std::vector& result, uint8_t maxLen); + + static bool ParseIntParam(const ::ohos::reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder); + static bool ParseStringParam(const ::ohos::reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder); + + static bool ParseLocalDateTime(const ::ohos::reminderAgentManager::manager::LocalDateTime& dateTimeReq, + struct tm& dateTime); + static void ParseWantAgent(const ::ohos::reminderAgentManager::manager::WantAgent& wantAgentReq, + std::shared_ptr& reminder); + static void ParseMaxScreenWantAgent(const ::ohos::reminderAgentManager::manager::MaxScreenWantAgent& wantAgentReq, + std::shared_ptr& reminder); + static bool ParseButton(const ::ohos::reminderAgentManager::manager::Button& buttonReq, + std::shared_ptr& reminder); + + static bool CreateReminderBase(const ::ohos::reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder); + static bool CreateReminderTimer(const ::ohos::reminderAgentManager::manager::ReminderRequestTimer& timerReq, + std::shared_ptr& reminder); + static bool CreateReminderAlarm(const ::ohos::reminderAgentManager::manager::ReminderRequestAlarm& alarmReq, + std::shared_ptr& reminder); + static bool CreateReminderCalendar( + const ::ohos::reminderAgentManager::manager::ReminderRequestCalendar& calendarReq, + std::shared_ptr& reminder); +}; +} // namespace OHOS::ReminderAgentManagerNapi + +#endif // BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_REMINDER_ANI_INCLUDE_REMINDER_ANI_COMMON_H \ No newline at end of file diff --git a/frameworks/reminder_ani/src/ani_constructor.cpp b/frameworks/reminder_ani/src/ani_constructor.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d7c7f6ae9e171973ed0753175a23e651f6fd4d5f --- /dev/null +++ b/frameworks/reminder_ani/src/ani_constructor.cpp @@ -0,0 +1,31 @@ +/* + * 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. + */ + +#include "taihe/runtime.hpp" +#include "ohos.reminderAgentManager.manager.ani.hpp" + +ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) +{ + ani_env *env; + if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { + return ANI_ERROR; + } + if (ANI_OK != ohos::reminderAgentManager::manager::ANIRegister(env)) { + std::cerr << "Error from ohos::reminderAgentManager::manager::ANIRegister" << std::endl; + return ANI_ERROR; + } + *result = ANI_VERSION_1; + return ANI_OK; +} \ No newline at end of file diff --git a/frameworks/reminder_ani/src/ohos.reminderAgentManager.impl.cpp b/frameworks/reminder_ani/src/ohos.reminderAgentManager.impl.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ad58892030b27903f01c53e8dea4c02c8bb6e751 --- /dev/null +++ b/frameworks/reminder_ani/src/ohos.reminderAgentManager.impl.cpp @@ -0,0 +1,178 @@ +/* + * 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. + */ + +#include "ohos.reminderAgentManager.manager.proj.hpp" +#include "ohos.reminderAgentManager.manager.impl.hpp" +#include "taihe/runtime.hpp" +#include "stdexcept" + +#include "ans_log_wrapper.h" +#include "reminder_helper.h" +#include "reminder_ani_common.h" + +using namespace OHOS; + +namespace { +static bool CheckReminderId(int32_t reminderId) +{ + if (reminderId < 0) { + ANSR_LOGW("Param reminder id is illegal."); + int32_t ret = ReminderAgentManagerNapi::Common::ERR_REMINDER_INVALID_PARAM; + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return false; + } + return true; +} + +int32_t PublishReminderSync(::ohos::reminderAgentManager::manager::ParamReminder const& reminderReq) +{ + std::shared_ptr reminder; + if (!ReminderAgentManagerNapi::Common::CreateReminder(reminderReq, reminder)) { + int32_t ret = ReminderAgentManagerNapi::Common::ERR_REMINDER_INVALID_PARAM; + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return -1; + } + int32_t ret = Notification::ReminderHelper::PublishReminder(reminder); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return -1; + } + return 0; +} + +void CancelReminderSync(int32_t reminderId) +{ + if (!CheckReminderId(reminderId)) { + return; + } + int32_t ret = Notification::ReminderHelper::CancelReminder(reminderId); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } +} + +::taihe::array<::ohos::reminderAgentManager::manager::ParamReminder> GetValidRemindersSync() +{ + std::vector validReminders; + int32_t ret = Notification::ReminderHelper::GetValidReminders(validReminders); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return; + } + return validReminders; +} + +void CancelAllRemindersSync() +{ + int32_t ret = Notification::ReminderHelper::CancelAllReminders(); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } +} + +void AddNotificationSlotSync(uintptr_t slot) +{ + +} + +void RemoveNotificationSlotSync(uintptr_t slotType) +{ + +} + +void AddExcludeDateSync(int32_t reminderId, uint64_t date) +{ + if (!CheckReminderId(reminderId)) { + return; + } + int32_t ret = ERR_OK; + if (date <= 0) { + ANSR_LOGW("Param exclude date is illegal."); + ret = ReminderAgentManagerNapi::Common::ERR_REMINDER_INVALID_PARAM; + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return; + } + ret = Notification::ReminderHelper::AddExcludeDate(reminderId, date); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } +} + +void DeleteExcludeDatesSync(int32_t reminderId) +{ + if (!CheckReminderId(reminderId)) { + return; + } + int32_t ret = Notification::ReminderHelper::DelExcludeDates(reminderId); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } +} + +::taihe::array GetExcludeDatesSync(int32_t reminderId) +{ + if (!CheckReminderId(reminderId)) { + return; + } + int32_t ret = Notification::ReminderHelper::DelExcludeDates(reminderId); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } + +} + +::taihe::array<::ohos::reminderAgentManager::manager::ReminderInfo> GetAllValidRemindersSync() +{ + std::vector validReminders; + int32_t ret = Notification::ReminderHelper::GetValidReminders(validReminders); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return; + } + return validReminders; +} + +void UpdateReminderSync(int32_t reminderId, ::ohos::reminderAgentManager::manager::ParamReminder const& reminderReq) +{ + if (!CheckReminderId(reminderId)) { + return; + } + std::shared_ptr reminder; + if (!ReminderAgentManagerNapi::Common::CreateReminder(reminderReq, reminder)) { + int32_t ret = ReminderAgentManagerNapi::Common::ERR_REMINDER_INVALID_PARAM; + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + return; + } + int32_t ret = Notification::ReminderHelper::UpdateReminder(reminderId, reminder); + if (ret != ERR_OK) { + ::taihe::set_business_error(ret, ReminderAgentManagerNapi::Common::getErrCodeMsg(ret)); + } +} +} // namespace + +// Since these macros are auto-generate, lint will cause false positive. +// NOLINTBEGIN +TH_EXPORT_CPP_API_PublishReminderSync(PublishReminderSync); +TH_EXPORT_CPP_API_CancelReminderSync(CancelReminderSync); +TH_EXPORT_CPP_API_GetValidRemindersSync(GetValidRemindersSync); +TH_EXPORT_CPP_API_CancelAllRemindersSync(CancelAllRemindersSync); +TH_EXPORT_CPP_API_AddNotificationSlotSync(AddNotificationSlotSync); +TH_EXPORT_CPP_API_RemoveNotificationSlotSync(RemoveNotificationSlotSync); +TH_EXPORT_CPP_API_AddExcludeDateSync(AddExcludeDateSync); +TH_EXPORT_CPP_API_DeleteExcludeDatesSync(DeleteExcludeDatesSync); +TH_EXPORT_CPP_API_GetExcludeDatesSync(GetExcludeDatesSync); +TH_EXPORT_CPP_API_GetAllValidRemindersSync(GetAllValidRemindersSync); +TH_EXPORT_CPP_API_UpdateReminderSync(UpdateReminderSync); +// NOLINTEND \ No newline at end of file diff --git a/frameworks/reminder_ani/src/reminder_ani_common.cpp b/frameworks/reminder_ani/src/reminder_ani_common.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0eea9d9ae460a04ec7e4b56494079d157c72a51d --- /dev/null +++ b/frameworks/reminder_ani/src/reminder_ani_common.cpp @@ -0,0 +1,341 @@ +/* + * 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. + */ + +#include "reminder_ani_common.h" + +#include "reminder_request_alarm.h" +#include "reminder_request_timer.h" +#include "reminder_request_calendar.h" + +using namespace ohos; + +namespace OHOS::ReminderAgentManagerNapi { +std::string Common::getErrCodeMsg(const int32_t errorCode) +{ + switch (errorCode) { + case ERR_REMINDER_PERMISSION_DENIED: + return "Permission denied."; + case ERR_REMINDER_INVALID_PARAM: + return "Parameter error."; + case ERR_REMINDER_NOTIFICATION_NOT_ENABLE: + return "Notification not enable."; + case ERR_REMINDER_NUMBER_OVERLOAD: + return "The number of reminders exceeds the limit."; + case ERR_REMINDER_NOT_EXIST: + return "The reminder not exist."; + case ERR_REMINDER_PACKAGE_NOT_EXIST: + return "The package name not exist."; + case ERR_REMINDER_CALLER_TOKEN_INVALID: + return "The caller token invalid."; + case ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED: + return "The data share permission denied."; + default: + return "Inner error"; + } +} + +bool Common::CreateReminder(const reminderAgentManager::manager::ParamReminder& reminderReq, + std::shared_ptr& reminder) +{ + switch (reminderReq.get_tag()) { + case reminderAgentManager::manager::ParamReminder::tag_t::timer: { + auto& timer = reminderReq.get_timer_ref(); + return CreateReminderTimer(timer, reminder); + } + case reminderAgentManager::manager::ParamReminder::tag_t::alarm: { + auto& alarm = reminderReq.get_alarm_ref(); + return CreateReminderAlarm(alarm, reminder); + } + case reminderAgentManager::manager::ParamReminder::tag_t::calendar: { + auto& calendar = reminderReq.get_calendar_ref(); + return CreateReminderCalendar(calendar, reminder); + } + default: + return false; + } +} + +bool Common::ParseIntArray(const ::taihe::array& values, std::vector& result, uint8_t maxLen) +{ + size_t size = values.size(); + if (size > maxLen) { + ANSR_LOGE("The max length of array is %{pulbic}hhu", maxLen); + return false; + } + for (size_t i = 0; i < size; ++i) { + int32_t value = values[i]; + if (value < 1 || value > static_cast(maxLen)) { + ANSR_LOGE("The array element must between [1, %{public}d].", maxLen); + return false; + } + result.push_back(static_cast(value)); + } + return true; +} + +bool Common::ParseIntParam(const reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder) +{ + if (reminderReq.ringDuration.has_value()) { + reminder->SetRingDuration(reminderReq.ringDuration.value()); + } + if (reminderReq.snoozeTimes.has_value()) { + reminder->SetSnoozeTimes(reminderReq.snoozeTimes.value()); + } + if (reminderReq.timeInterval.has_value()) { + reminder->SetTimeInterval(reminderReq.timeInterval.value()); + } + if (reminderReq.titleResourceId.has_value()) { + reminder->SetTitleResourceId(reminderReq.titleResourceId.value()); + } + if (reminderReq.contentResourceId.has_value()) { + reminder->SetContentResourceId(reminderReq.contentResourceId.value()); + } + if (reminderReq.expiredContentResourceId.has_value()) { + reminder->SetExpiredContentResourceId(reminderReq.expiredContentResourceId.value()); + } + if (reminderReq.snoozeContentResourceId.has_value()) { + reminder->SetSnoozeContentResourceId(reminderReq.snoozeContentResourceId.value()); + } + if (reminderReq.notificationId.has_value()) { + reminder->SetNotificationId(reminderReq.notificationId.value()); + } + if (reminderReq.autoDeletedTime.has_value()) { + reminder->SetAutoDeletedTime(reminderReq.autoDeletedTime.value()); + } + return true; +} + +bool Common::ParseStringParam(const reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder) +{ + if (reminderReq.title.has_value()) { + reminder->SetTitle(reminderReq.title.value().c_str()); + } + if (reminderReq.content.has_value()) { + reminder->SetContent(reminderReq.content.value().c_str()); + } + if (reminderReq.expiredContent.has_value()) { + reminder->SetExpiredContent(reminderReq.expiredContent.value().c_str()); + } + if (reminderReq.snoozeContent.has_value()) { + reminder->SetSnoozeContent(reminderReq.snoozeContent.value().c_str()); + } + if (reminderReq.groupId.has_value()) { + reminder->SetGroupId(reminderReq.groupId.value().c_str()); + } + if (reminderReq.customRingUri.has_value()) { + reminder->SetCustomRingUri(reminderReq.customRingUri.value().c_str()); + } +} + +bool Common::ParseLocalDateTime(const reminderAgentManager::manager::LocalDateTime& dateTimeReq, + struct tm& dateTime) +{ + if (dateTimeReq.year < 0 || dateTimeReq.year > UINT16_MAX) { + ANSR_LOGE("Param[year] out of range[0, %{public}d]", UINT16_MAX); + return false; + } + dateTime.tm_year = ReminderRequest::GetCTime(ReminderRequest::TimeTransferType::YEAR, dateTimeReq.year); + + if (dateTimeReq.month < 1 || dateTimeReq.month > ReminderRequestCalendar::MAX_MONTHS_OF_YEAR) { + ANSR_LOGE("Param[month] out of range[1, %{public}hhu]", ReminderRequestCalendar::MAX_MONTHS_OF_YEAR); + return false; + } + dateTime.tm_mon = ReminderRequest::GetCTime(ReminderRequest::TimeTransferType::MONTH, dateTimeReq.month); + + uint8_t maxDaysOfMonth = ReminderRequestCalendar::GetDaysOfMonth(static_cast(dateTimeReq.year), + static_cast(dateTimeReq.month)); + if ((dateTimeReq.day < 1) || (dateTimeReq.day > maxDaysOfMonth)) { + ANSR_LOGW("Param[day] out of range[1, %{public}hhu]", maxDaysOfMonth); + return false; + } + dateTime.tm_mday = dateTimeReq.day; + + constexpr uint8_t maxHour = 23; + if (dateTimeReq.hour < 0 || dateTimeReq.hour > maxHour) { + ANSR_LOGW("Param[hour] out of range[0, %{public}hhu]", maxHour); + return false; + } + dateTime.tm_hour = dateTimeReq.hour; + + constexpr uint8_t maxMinute = 59; + if (dateTimeReq.minute < 0 || dateTimeReq.minute > maxMinute) { + ANSR_LOGW("Param[minute] out of range[0, %{public}hhu]", maxMinute); + return false; + } + dateTime.tm_min = dateTimeReq.minute; + + if (dateTimeReq.second.has_value()) { + // undo check second + dateTime.tm_sec = dateTimeReq.second.value(); + } else { + dateTime.tm_sec = 0; + } + dateTime.tm_isdst = -1; + return true; +} + + +void Common::ParseWantAgent(const reminderAgentManager::manager::WantAgent& wantAgentReq, + std::shared_ptr& reminder) +{ + auto wantAgent = std::make_shared(); + reminder->SetWantAgentInfo(wantAgent); + wantAgent->pkgName = std::move(std::string(wantAgentReq.pkgName.c_str())); + wantAgent->abilityName = std::move(std::string(wantAgentReq.abilityName.c_str())); + if (wantAgentReq.uri.has_value()) { + wantAgent->uri = std::move(std::string(wantAgentReq.uri.value().c_str())); + } + if (!wantAgentReq.parameters.has_value()) { + return; + } + + for (const auto& [key, value] : wantAgentReq.parameters.value()) { + switch (value.get_tag()) { + case reminderAgentManager::manager::ParameType::tag_t::string: { + wantAgent->parameters.SetString(key, value.get_string()); + break; + } + case reminderAgentManager::manager::ParamType::tag_t::int32: { + wantAgent->parameters.SetInt(key, value.get_int32()); + break; + } + case reminderAgentManager::manager::ParamType::tag_t::int64: { + wantAgent->parameters.SetInt(key, value.get_int64()); + break; + } + case reminderAgentManager::manager::ParamType::tag_t::bool: { + wantAgent->parameters.SetBool(key, value.get_bool()); + break; + } + case reminderAgentManager::manager::ParamType::tag_t::double: { + wantAgent->parameters.SetDouble(key, value.get_double()); + break; + } + } + } +} + +void Common::ParseMaxScreenWantAgent(const reminderAgentManager::manager::MaxScreenWantAgent& wantAgentReq, + std::shared_ptr& reminder) +{ + auto wantAgent = std::shared_ptr(); + reminder->SetMaxScreenAgentInfo(wantAgent); + wantAgent->pkgName = std::move(std::string(wantAgentReq.pkgName.c_str())); + wantAgent->abilityName = std::move(std::string(wantAgentReq.abilityName.c_str())); +} + +bool Common::CreateReminderBase(const reminderAgentManager::manager::ReminderRequest& reminderReq, + std::shared_ptr& reminder) +{ + if (!ParseIntParam(reminderReq, reminder)) { + return false; + } + if (!ParseStringParam(reminderReq, reminder)) { + return false; + } + if (reminderReq.tapDismissed.has_value()) { + reminder->SetTapDismissed(reminderReq.tapDismissed.value()); + } + // undo slotType, snoozeSlotType + if (reminderReq.wantAgent.has_value()) { + ParseWantAgent(reminderReq.wantAgent.value(), reminder); + } + if (reminderReq.maxScreenWantAgent.has_value()) { + ParseMaxScreenWantAgent(reminderReq.maxScreenWantAgent.value(), reminder); + } + return true; +} + +bool Common::CreateReminderTimer(const reminderAgentManager::manager::ReminderRequestTimer& timerReq, + std::shared_ptr& reminder) +{ + uint64_t triggerTimeInSeconds = timerReq.triggerTimeInSeconds; + if (triggerTimeInSeconds >= (UINT64_MAX / ReminderRequest::MILLI_SECONDS)) { + ANSR_LOGE("Param[triggerTimeInSeconds] out of range."); + return false; + } + auto timer = std::make_shared(triggerTimeInSeconds); + if (!CreateReminderBase(timerReq.base, reminder)) { + return false; + } + reminder = std::move(timer); + return true; +} + +bool Common::CreateReminderAlarm(const reminderAgentManager::manager::ReminderRequestAlarm& alarmReq, + std::shared_ptr& reminder) +{ + constexpr int32_t maxHour = 23; + constexpr int32_t maxMinute = 59; + int32_t hour = alarmReq.hour; + int32_t minute = alarmReq.minute; + if (hour < 0 || hour > maxHour) { + ANSR_LOGE("Param[hour] out of range[0, 23]."); + return false; + } + if (minute < 0 || minute > maxMinute) { + ANSR_LOGE("Param[minute] out of range[0, 59]."); + return false; + } + std::vector daysOfWeek; + constexpr uint8_t maxDaysOfWeek = 7; + if (alarmReq.daysOfWeek.has_value() && + !ParseIntArray(alramReq.daysOfWeek.value(), daysOfWeek, maxDaysOfWeek)) { + return false; + } + auto alarm = std::make_shared(static_cast(hour), + static_cast(minute), daysOfWeek); + if (!CreateReminderBase(alarmReq.base, reminder)) { + return false; + } + reminder = std::move(alarm); + return true; +} + +bool Common::CreateReminderCalendar(const reminderAgentManager::manager::ReminderRequestCalendar& calendarReq, + std::shared_ptr& reminder) +{ + struct tm dateTime; + if (!ParseLocalDateTime(calendarReq.dateTime, dateTime)) { + return false; + } + std::vector repeatMonths; + if (calendarReq.repeatMonths.has_value() && !ParseIntArray(calendarReq.repeatMonths.value(), + repeatMonths, ReminderRequestCalendar::MAX_MONTHS_OF_YEAR)) { + return false; + } + std::vector repeatDays; + if (calendarReq.repeatDays.has_value() && !ParseIntArray(calendarReq.repeatDays.value(), + repeatDays, ReminderRequestCalendar::MAX_DAYS_OF_MONTH)) { + return false; + } + std::vector daysOfWeek; + constexpr uint8_t maxDaysOfWeek = 7; + if (calendarReq.daysOfWeek.has_value() && !ParseIntArray(calendarReq.daysOfWeek.value(), + daysOfWeek, maxDaysOfWeek)) { + return false; + } + std::shared_ptr calendar = + std::make_shared(); + if (!CreateReminderBase(calendarReq.base, reminder)) { + return false; + } + + reminder = std::move(calendar); + return true; +} +} \ No newline at end of file