1 /*
2 * Copyright (c) 2024 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 #include "reminder_store_strategy.h"
17
18 #include "ans_log_wrapper.h"
19 #include "reminder_store.h"
20 #include "reminder_table.h"
21 #include "reminder_table_old.h"
22 #include "reminder_request_alarm.h"
23 #include "reminder_request_timer.h"
24 #include "reminder_request_calendar.h"
25
26 namespace OHOS {
27 namespace Notification {
AppendValuesBucket(const sptr<ReminderRequest> & reminder,NativeRdb::ValuesBucket & values,const bool oldVersion)28 void ReminderStrategy::AppendValuesBucket(const sptr<ReminderRequest>& reminder,
29 NativeRdb::ValuesBucket &values, const bool oldVersion)
30 {
31 values.PutInt(ReminderBaseTable::REMINDER_ID, reminder->GetReminderId());
32 values.PutString(ReminderBaseTable::PACKAGE_NAME, reminder->GetBundleName());
33 values.PutInt(ReminderBaseTable::USER_ID, reminder->GetUserId());
34 values.PutInt(ReminderBaseTable::UID, reminder->GetUid());
35 values.PutString(ReminderBaseTable::SYSTEM_APP, reminder->IsSystemApp() ? "true" : "false");
36 values.PutInt(ReminderBaseTable::REMINDER_TYPE, static_cast<int32_t>(reminder->GetReminderType()));
37 values.PutLong(ReminderBaseTable::REMINDER_TIME, reminder->GetReminderTimeInMilli());
38 values.PutLong(ReminderBaseTable::TRIGGER_TIME, reminder->GetTriggerTimeInMilli());
39 values.PutLong(ReminderBaseTable::TIME_INTERVAL, reminder->GetTimeInterval());
40 values.PutInt(ReminderBaseTable::SNOOZE_TIMES, reminder->GetSnoozeTimes());
41 values.PutInt(ReminderBaseTable::DYNAMIC_SNOOZE_TIMES, reminder->GetSnoozeTimesDynamic());
42 values.PutLong(ReminderBaseTable::RING_DURATION, reminder->GetRingDuration());
43 values.PutString(ReminderBaseTable::IS_EXPIRED, reminder->IsExpired() ? "true" : "false");
44 values.PutInt(ReminderBaseTable::STATE, reminder->GetState());
45 values.PutString(ReminderBaseTable::ACTION_BUTTON_INFO, reminder->SerializeButtonInfo());
46 values.PutString(ReminderBaseTable::CUSTOM_BUTTON_URI, reminder->GetCustomButtonUri());
47 values.PutInt(ReminderBaseTable::SLOT_ID, reminder->GetSlotType());
48 values.PutInt(ReminderBaseTable::SNOOZE_SLOT_ID, reminder->GetSnoozeSlotType());
49 values.PutInt(ReminderBaseTable::NOTIFICATION_ID, reminder->GetNotificationId());
50 values.PutString(ReminderBaseTable::TITLE, reminder->GetTitle());
51 values.PutInt(ReminderBaseTable::TITLE_RESOURCE_ID, reminder->GetTitleResourceId());
52 values.PutString(ReminderBaseTable::CONTENT, reminder->GetContent());
53 values.PutInt(ReminderBaseTable::CONTENT_RESOURCE_ID, reminder->GetContentResourceId());
54 values.PutString(ReminderBaseTable::SNOOZE_CONTENT, reminder->GetSnoozeContent());
55 values.PutInt(ReminderBaseTable::SNOOZE_CONTENT_RESOURCE_ID, reminder->GetSnoozeContentResourceId());
56 values.PutString(ReminderBaseTable::EXPIRED_CONTENT, reminder->GetExpiredContent());
57 values.PutInt(ReminderBaseTable::EXPIRED_CONTENT_RESOURCE_ID, reminder->GetExpiredContentResourceId());
58
59 if (oldVersion) {
60 values.PutString(ReminderBaseTable::WANT_AGENT, reminder->GetWantAgentStr());
61 values.PutString(ReminderBaseTable::MAX_SCREEN_WANT_AGENT, reminder->GetMaxWantAgentStr());
62 } else {
63 std::string wantInfoStr;
64 std::string maxWantInfoStr;
65 reminder->SerializeWantAgent(wantInfoStr, maxWantInfoStr);
66 values.PutString(ReminderBaseTable::WANT_AGENT, wantInfoStr);
67 values.PutString(ReminderBaseTable::MAX_SCREEN_WANT_AGENT, maxWantInfoStr);
68 }
69
70 values.PutString(ReminderBaseTable::TAP_DISMISSED, reminder->IsTapDismissed() ? "true" : "false");
71 values.PutLong(ReminderBaseTable::AUTO_DELETED_TIME, reminder->GetAutoDeletedTime());
72 values.PutString(ReminderBaseTable::GROUP_ID, reminder->GetGroupId());
73 values.PutString(ReminderBaseTable::CUSTOM_RING_URI, reminder->GetCustomRingUri());
74 values.PutString(ReminderBaseTable::CREATOR_BUNDLE_NAME, reminder->GetCreatorBundleName());
75 values.PutInt(ReminderBaseTable::CREATOR_UID, reminder->GetCreatorUid());
76 }
77
RecoverTimeFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)78 void ReminderStrategy::RecoverTimeFromOldVersion(sptr<ReminderRequest>& reminder,
79 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
80 {
81 uint64_t reminderTime = 0;
82 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderTable::REMINDER_TIME, reminderTime);
83 reminder->SetReminderTimeInMilli(reminderTime);
84
85 uint64_t triggerTime = 0;
86 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderTable::TRIGGER_TIME, triggerTime);
87 reminder->SetTriggerTimeInMilli(triggerTime);
88
89 uint64_t timeInterval = 0;
90 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderTable::TIME_INTERVAL, timeInterval);
91 reminder->SetTimeInterval(timeInterval);
92
93 uint8_t snoozeTimes = 0;
94 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::SNOOZE_TIMES, snoozeTimes);
95 reminder->SetSnoozeTimes(snoozeTimes);
96
97 uint8_t dynamicSnoozeTimes = 0;
98 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::DYNAMIC_SNOOZE_TIMES, dynamicSnoozeTimes);
99 reminder->SetSnoozeTimesDynamic(dynamicSnoozeTimes);
100
101 uint64_t ringDuration = 0;
102 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderTable::RING_DURATION, ringDuration);
103 reminder->SetRingDuration(ringDuration);
104
105 int64_t autoDeletedTime = 0;
106 ReminderStrategy::GetRdbValue<int64_t>(resultSet, ReminderTable::AUTO_DELETED_TIME, autoDeletedTime);
107 reminder->SetAutoDeletedTime(autoDeletedTime);
108 }
109
RecoverIdFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)110 void ReminderStrategy::RecoverIdFromOldVersion(sptr<ReminderRequest>& reminder,
111 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
112 {
113 int32_t reminderId = 0;
114 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::REMINDER_ID, reminderId);
115 reminder->SetReminderId(reminderId);
116
117 int32_t userId = 0;
118 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::USER_ID, userId);
119 reminder->InitUserId(userId);
120
121 int32_t uid = 0;
122 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::UID, uid);
123 reminder->InitUid(uid);
124
125 int32_t reminderType = 0;
126 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::REMINDER_TYPE, reminderType);
127 reminder->SetReminderType(ReminderRequest::ReminderType(reminderType));
128
129 int32_t slotType = 0;
130 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::SLOT_ID, slotType);
131 reminder->SetSlotType(NotificationConstant::SlotType(slotType));
132
133 int32_t snoozeSlotType = 0;
134 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::SNOOZE_SLOT_ID, snoozeSlotType);
135 reminder->SetSnoozeSlotType(NotificationConstant::SlotType(snoozeSlotType));
136
137 int32_t notificationId = 0;
138 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderTable::NOTIFICATION_ID, notificationId);
139 reminder->SetNotificationId(notificationId);
140
141 std::string groupId;
142 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::GROUP_ID, groupId);
143 reminder->SetGroupId(groupId);
144 }
145
RecoverContextFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)146 void ReminderStrategy::RecoverContextFromOldVersion(sptr<ReminderRequest>& reminder,
147 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
148 {
149 std::string bundleName;
150 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::PKG_NAME, bundleName);
151 reminder->InitBundleName(bundleName);
152
153 std::string title;
154 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::TITLE, title);
155 reminder->SetTitle(title);
156
157 std::string content;
158 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::CONTENT, content);
159 reminder->SetContent(content);
160
161 std::string snoozeContent;
162 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::SNOOZE_CONTENT, snoozeContent);
163 reminder->SetSnoozeContent(snoozeContent);
164
165 std::string expiredContent;
166 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::EXPIRED_CONTENT, expiredContent);
167 reminder->SetExpiredContent(expiredContent);
168
169 std::string customButtonUri;
170 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::CUSTOM_BUTTON_URI, customButtonUri);
171 reminder->SetCustomButtonUri(customButtonUri);
172
173 std::string customRingUri;
174 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::CUSTOM_RING_URI, customRingUri);
175 reminder->SetCustomRingUri(customRingUri);
176
177 std::string creatorBundleName;
178 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::CREATOR_BUNDLE_NAME, creatorBundleName);
179 reminder->InitCreatorBundleName(creatorBundleName);
180 }
181
RecoverFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)182 void ReminderStrategy::RecoverFromOldVersion(sptr<ReminderRequest>& reminder,
183 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
184 {
185 if (reminder == nullptr || resultSet == nullptr) {
186 ANSR_LOGE("ResultSet is null or reminder is null");
187 return;
188 }
189
190 ReminderStrategy::RecoverTimeFromOldVersion(reminder, resultSet);
191 ReminderStrategy::RecoverIdFromOldVersion(reminder, resultSet);
192 ReminderStrategy::RecoverContextFromOldVersion(reminder, resultSet);
193
194 std::string isSystemApp;
195 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::SYS_APP, isSystemApp);
196 reminder->SetSystemApp(isSystemApp == "true" ? true : false);
197
198 std::string isExpired;
199 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::IS_EXPIRED, isExpired);
200 reminder->SetExpired(isExpired == "true" ? true : false);
201
202 std::string actionButtons;
203 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::ACTION_BUTTON_INFO, actionButtons);
204 reminder->DeserializeButtonInfo(actionButtons);
205
206 uint8_t state = 0;
207 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::STATE, state);
208 reminder->SetState(state);
209
210 uint8_t repeatDaysOfWeek = 0;
211 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::REPEAT_DAYS_OF_WEEK, repeatDaysOfWeek);
212 reminder->SetRepeatDaysOfWeek(repeatDaysOfWeek);
213
214 std::string wantAgent;
215 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::AGENT, wantAgent);
216 reminder->SetWantAgentStr(wantAgent);
217
218 std::string maxScreenWantAgent;
219 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::MAX_SCREEN_AGENT, maxScreenWantAgent);
220 reminder->SetMaxWantAgentStr(maxScreenWantAgent);
221
222 std::string tapDismissed;
223 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderTable::TAP_DISMISSED, tapDismissed);
224 reminder->SetTapDismissed(tapDismissed == "true" ? true : false);
225 }
226
RecoverTimeFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)227 void ReminderStrategy::RecoverTimeFromDb(sptr<ReminderRequest>& reminder,
228 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
229 {
230 uint64_t reminderTime = 0;
231 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderBaseTable::REMINDER_TIME, reminderTime);
232 reminder->SetReminderTimeInMilli(reminderTime);
233
234 uint64_t triggerTime = 0;
235 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderBaseTable::TRIGGER_TIME, triggerTime);
236 reminder->SetTriggerTimeInMilli(triggerTime);
237
238 uint64_t timeInterval = 0;
239 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderBaseTable::TIME_INTERVAL, timeInterval);
240 reminder->SetTimeInterval(timeInterval);
241
242 uint8_t snoozeTimes = 0;
243 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderBaseTable::SNOOZE_TIMES, snoozeTimes);
244 reminder->SetSnoozeTimes(snoozeTimes);
245
246 uint8_t dynamicSnoozeTimes = 0;
247 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderBaseTable::DYNAMIC_SNOOZE_TIMES, dynamicSnoozeTimes);
248 reminder->SetSnoozeTimesDynamic(dynamicSnoozeTimes);
249
250 uint64_t ringDuration = 0;
251 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderBaseTable::RING_DURATION, ringDuration);
252 reminder->SetRingDuration(ringDuration);
253
254 int64_t autoDeletedTime = 0;
255 ReminderStrategy::GetRdbValue<int64_t>(resultSet, ReminderBaseTable::AUTO_DELETED_TIME, autoDeletedTime);
256 reminder->SetAutoDeletedTime(autoDeletedTime);
257 }
258
RecoverIdFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)259 void ReminderStrategy::RecoverIdFromDb(sptr<ReminderRequest>& reminder,
260 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
261 {
262 int32_t reminderId = 0;
263 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::REMINDER_ID, reminderId);
264 reminder->SetReminderId(reminderId);
265
266 int32_t userId = 0;
267 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::USER_ID, userId);
268 reminder->InitUserId(userId);
269
270 int32_t uid = 0;
271 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::UID, uid);
272 reminder->InitUid(uid);
273
274 int32_t reminderType = 0;
275 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::REMINDER_TYPE, reminderType);
276 reminder->SetReminderType(ReminderRequest::ReminderType(reminderType));
277
278 int32_t slotType = 0;
279 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::SLOT_ID, slotType);
280 reminder->SetSlotType(NotificationConstant::SlotType(slotType));
281
282 int32_t snoozeSlotType = 0;
283 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::SNOOZE_SLOT_ID, snoozeSlotType);
284 reminder->SetSnoozeSlotType(NotificationConstant::SlotType(snoozeSlotType));
285
286 int32_t notificationId = 0;
287 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::NOTIFICATION_ID, notificationId);
288 reminder->SetNotificationId(notificationId);
289
290 std::string groupId;
291 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::GROUP_ID, groupId);
292 reminder->SetGroupId(groupId);
293
294 int32_t creatorUid;
295 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::CREATOR_UID, creatorUid);
296 reminder->InitCreatorUid(creatorUid);
297
298 int32_t titleResourceId = 0;
299 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::TITLE_RESOURCE_ID, titleResourceId);
300 reminder->SetTitleResourceId(titleResourceId);
301
302 int32_t contentResourceId = 0;
303 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::CONTENT_RESOURCE_ID, contentResourceId);
304 reminder->SetContentResourceId(contentResourceId);
305
306 int32_t snoozeContentResourceId = 0;
307 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::SNOOZE_CONTENT_RESOURCE_ID,
308 snoozeContentResourceId);
309 reminder->SetSnoozeContentResourceId(snoozeContentResourceId);
310
311 int32_t expiredContentResourceId = 0;
312 ReminderStrategy::GetRdbValue<int32_t>(resultSet, ReminderBaseTable::EXPIRED_CONTENT_RESOURCE_ID,
313 expiredContentResourceId);
314 reminder->SetExpiredContentResourceId(expiredContentResourceId);
315 }
316
RecoverContextFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)317 void ReminderStrategy::RecoverContextFromDb(sptr<ReminderRequest>& reminder,
318 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
319 {
320 std::string bundleName;
321 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::PACKAGE_NAME, bundleName);
322 reminder->InitBundleName(bundleName);
323
324 std::string customButtonUri;
325 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::CUSTOM_BUTTON_URI, customButtonUri);
326 reminder->SetCustomButtonUri(customButtonUri);
327
328 std::string title;
329 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::TITLE, title);
330 reminder->SetTitle(title);
331
332 std::string content;
333 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::CONTENT, content);
334 reminder->SetContent(content);
335
336 std::string snoozeContent;
337 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::SNOOZE_CONTENT, snoozeContent);
338 reminder->SetSnoozeContent(snoozeContent);
339
340 std::string expiredContent;
341 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::EXPIRED_CONTENT, expiredContent);
342 reminder->SetExpiredContent(expiredContent);
343
344 std::string customRingUri;
345 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::CUSTOM_RING_URI, customRingUri);
346 reminder->SetCustomRingUri(customRingUri);
347
348 std::string creatorBundleName;
349 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::CREATOR_BUNDLE_NAME, creatorBundleName);
350 reminder->InitCreatorBundleName(creatorBundleName);
351 }
352
RecoverFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)353 void ReminderStrategy::RecoverFromDb(sptr<ReminderRequest>& reminder,
354 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
355 {
356 if (reminder == nullptr || resultSet == nullptr) {
357 ANSR_LOGE("ResultSet is null or reminder is null");
358 return;
359 }
360 ReminderStrategy::RecoverTimeFromDb(reminder, resultSet);
361 ReminderStrategy::RecoverIdFromDb(reminder, resultSet);
362 ReminderStrategy::RecoverContextFromDb(reminder, resultSet);
363
364 uint8_t state = 0;
365 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderBaseTable::STATE, state);
366 reminder->SetState(state);
367
368 std::string isSystemApp;
369 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::SYSTEM_APP, isSystemApp);
370 reminder->SetSystemApp(isSystemApp == "true" ? true : false);
371
372 std::string isExpired;
373 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::IS_EXPIRED, isExpired);
374 reminder->SetExpired(isExpired == "true" ? true : false);
375
376 std::string actionButtons;
377 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::ACTION_BUTTON_INFO, actionButtons);
378 reminder->DeserializeButtonInfo(actionButtons);
379
380 std::string wantAgent;
381 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::WANT_AGENT, wantAgent);
382 reminder->DeserializeWantAgent(wantAgent, 0);
383
384 std::string maxWantAgent;
385 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::MAX_SCREEN_WANT_AGENT, maxWantAgent);
386 reminder->DeserializeWantAgent(maxWantAgent, 1);
387
388 std::string tapDismissed;
389 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderBaseTable::TAP_DISMISSED, tapDismissed);
390 reminder->SetTapDismissed(tapDismissed == "true" ? true : false);
391 }
392
AppendValuesBucket(const sptr<ReminderRequest> & reminder,NativeRdb::ValuesBucket & values)393 void ReminderTimerStrategy::AppendValuesBucket(const sptr<ReminderRequest>& reminder,
394 NativeRdb::ValuesBucket& values)
395 {
396 uint64_t seconds = 0;
397 if (reminder->GetReminderType() == ReminderRequest::ReminderType::TIMER) {
398 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr());
399 seconds = timer->GetInitInfo();
400 }
401 values.PutInt(ReminderTimerTable::REMINDER_ID, reminder->GetReminderId());
402 values.PutLong(ReminderTimerTable::TRIGGER_SECOND, seconds);
403 values.PutLong(ReminderTimerTable::START_DATE_TIME, 0);
404 values.PutLong(ReminderTimerTable::END_DATE_TIME, 0);
405 }
406
RecoverFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)407 void ReminderTimerStrategy::RecoverFromOldVersion(sptr<ReminderRequest>& reminder,
408 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
409 {
410 if (resultSet == nullptr || reminder == nullptr) {
411 ANSR_LOGE("ResultSet is null or reminder is null");
412 return;
413 }
414 ReminderStrategy::RecoverFromOldVersion(reminder, resultSet);
415 }
416
RecoverFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & baseResult,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)417 void ReminderTimerStrategy::RecoverFromDb(sptr<ReminderRequest>& reminder,
418 const std::shared_ptr<NativeRdb::ResultSet>& baseResult, const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
419 {
420 if (resultSet == nullptr || reminder == nullptr || baseResult == nullptr) {
421 ANSR_LOGE("ResultSet is null or reminder is null");
422 return;
423 }
424 ReminderStrategy::RecoverFromDb(reminder, baseResult);
425 if (reminder->GetReminderType() == ReminderRequest::ReminderType::TIMER) {
426 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr());
427 uint64_t seconds;
428 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderTimerTable::TRIGGER_SECOND, seconds);
429 timer->SetInitInfo(seconds);
430 }
431 }
432
AppendValuesBucket(const sptr<ReminderRequest> & reminder,NativeRdb::ValuesBucket & values)433 void ReminderAlarmStrategy::AppendValuesBucket(const sptr<ReminderRequest>& reminder,
434 NativeRdb::ValuesBucket& values)
435 {
436 uint8_t hour = 0;
437 uint8_t minute = 0;
438 uint8_t repeatDaysOfWeek = 0;
439 if (reminder->GetReminderType() == ReminderRequest::ReminderType::ALARM) {
440 ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr());
441 hour = alarm->GetHour();
442 minute = alarm->GetMinute();
443 repeatDaysOfWeek = alarm->GetRepeatDaysOfWeek();
444 }
445 values.PutInt(ReminderAlarmTable::REMINDER_ID, reminder->GetReminderId());
446 values.PutInt(ReminderAlarmTable::ALARM_HOUR, hour);
447 values.PutInt(ReminderAlarmTable::ALARM_MINUTE, minute);
448 values.PutInt(ReminderAlarmTable::REPEAT_DAYS_OF_WEEK, repeatDaysOfWeek);
449 }
450
RecoverFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)451 void ReminderAlarmStrategy::RecoverFromOldVersion(sptr<ReminderRequest>& reminder,
452 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
453 {
454 if (resultSet == nullptr || reminder == nullptr) {
455 ANSR_LOGE("ResultSet is null or reminder is null");
456 return;
457 }
458 ReminderStrategy::RecoverFromOldVersion(reminder, resultSet);
459
460 if (reminder->GetReminderType() == ReminderRequest::ReminderType::ALARM) {
461 ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr());
462 uint8_t hour = 0;
463 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::ALARM_HOUR, hour);
464 alarm->SetHour(hour);
465
466 uint8_t minute = 0;
467 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::ALARM_MINUTE, minute);
468 alarm->SetMinute(minute);
469 }
470 }
471
RecoverFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & baseResult,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)472 void ReminderAlarmStrategy::RecoverFromDb(sptr<ReminderRequest>& reminder,
473 const std::shared_ptr<NativeRdb::ResultSet>& baseResult, const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
474 {
475 if (resultSet == nullptr || reminder == nullptr || baseResult == nullptr) {
476 ANSR_LOGE("ResultSet is null or reminder is null");
477 return;
478 }
479 ReminderStrategy::RecoverFromDb(reminder, baseResult);
480 if (reminder->GetReminderType() == ReminderRequest::ReminderType::ALARM) {
481 ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr());
482 uint8_t hour = 0;
483 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderAlarmTable::ALARM_HOUR, hour);
484 alarm->SetHour(hour);
485
486 uint8_t minute = 0;
487 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderAlarmTable::ALARM_MINUTE, minute);
488 alarm->SetMinute(minute);
489
490 uint8_t repeatDaysOfWeek = 0;
491 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderAlarmTable::REPEAT_DAYS_OF_WEEK, repeatDaysOfWeek);
492 alarm->SetRepeatDaysOfWeek(repeatDaysOfWeek);
493 }
494 }
495
AppendValuesBucket(const sptr<ReminderRequest> & reminder,NativeRdb::ValuesBucket & values)496 void ReminderCalendarStrategy::AppendValuesBucket(const sptr<ReminderRequest>& reminder,
497 NativeRdb::ValuesBucket& values)
498 {
499 uint16_t firstDesignateYear = 0;
500 uint8_t firstDesignateMonth = 0;
501 uint8_t firstDesignateDay = 0;
502 uint64_t dateTime = 0;
503 uint32_t repeatDay = 0;
504 uint16_t repeatMonth = 0;
505 uint8_t repeatDaysOfWeek = 0;
506 uint64_t endDateTime = 0;
507 uint64_t lastStartDateTime = 0;
508 std::string rruleWantAgent;
509 std::string excludeDates;
510 if (reminder != nullptr && reminder->GetReminderType() == ReminderRequest::ReminderType::CALENDAR) {
511 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
512 if (calendar != nullptr) {
513 repeatDay = calendar->GetRepeatDay();
514 repeatMonth = calendar->GetRepeatMonth();
515 firstDesignateYear = calendar->GetFirstDesignateYear();
516 firstDesignateMonth = calendar->GetFirstDesignageMonth();
517 firstDesignateDay = calendar->GetFirstDesignateDay();
518 dateTime = calendar->GetDateTime();
519 repeatDaysOfWeek = calendar->GetRepeatDaysOfWeek();
520 endDateTime = calendar->GetEndDateTime();
521 lastStartDateTime = calendar->GetLastStartDateTime();
522 rruleWantAgent = calendar->SerializationRRule();
523 excludeDates = calendar->SerializationExcludeDates();
524 }
525 }
526 values.PutInt(ReminderCalendarTable::REMINDER_ID, reminder->GetReminderId());
527 values.PutInt(ReminderCalendarTable::FIRST_DESIGNATE_YEAR, firstDesignateYear);
528 values.PutInt(ReminderCalendarTable::FIRST_DESIGNATE_MONTH, firstDesignateMonth);
529 values.PutInt(ReminderCalendarTable::FIRST_DESIGNATE_DAY, firstDesignateDay);
530 values.PutLong(ReminderCalendarTable::CALENDAR_DATE_TIME, dateTime);
531 values.PutLong(ReminderCalendarTable::CALENDAR_END_DATE_TIME, endDateTime);
532 values.PutLong(ReminderCalendarTable::CALENDAR_LAST_DATE_TIME, lastStartDateTime);
533 values.PutInt(ReminderCalendarTable::REPEAT_DAYS, repeatDay);
534 values.PutInt(ReminderCalendarTable::REPEAT_MONTHS, repeatMonth);
535 values.PutInt(ReminderCalendarTable::REPEAT_DAYS_OF_WEEK, repeatDaysOfWeek);
536 values.PutString(ReminderCalendarTable::RRULE_WANT_AGENT, rruleWantAgent);
537 values.PutString(ReminderCalendarTable::EXCLUDE_DATES, excludeDates);
538 }
539
RecoverFromOldVersion(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)540 void ReminderCalendarStrategy::RecoverFromOldVersion(sptr<ReminderRequest>& reminder,
541 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
542 {
543 if (resultSet == nullptr || reminder == nullptr) {
544 ANSR_LOGE("ResultSet is null or reminder is null");
545 return;
546 }
547 ReminderStrategy::RecoverFromOldVersion(reminder, resultSet);
548 if (reminder->GetReminderType() == ReminderRequest::ReminderType::CALENDAR) {
549 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
550 uint32_t repeatDay = 0;
551 ReminderStrategy::GetRdbValue<uint32_t>(resultSet, ReminderTable::REPEAT_DAYS, repeatDay);
552 calendar->SetRepeatDay(repeatDay);
553
554 uint16_t repeatMonth = 0;
555 ReminderStrategy::GetRdbValue<uint16_t>(resultSet, ReminderTable::REPEAT_MONTHS, repeatMonth);
556 calendar->SetRepeatMonth(repeatMonth);
557
558 uint16_t firstDesignateYear = 0;
559 ReminderStrategy::GetRdbValue<uint16_t>(resultSet, ReminderTable::FIRST_DESIGNATE_YEAR, firstDesignateYear);
560 calendar->SetFirstDesignateYear(firstDesignateYear);
561
562 uint8_t firstDesignateMonth = 0;
563 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::FIRST_DESIGNATE_MONTH, firstDesignateMonth);
564 calendar->SetFirstDesignageMonth(firstDesignateMonth);
565
566 uint8_t firstDesignateDay = 0;
567 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::FIRST_DESIGNATE_DAY, firstDesignateDay);
568 calendar->SetFirstDesignateDay(firstDesignateDay);
569
570 uint16_t year = 0;
571 ReminderStrategy::GetRdbValue<uint16_t>(resultSet, ReminderTable::CALENDAR_YEAR, year);
572 calendar->SetYear(year);
573
574 uint8_t month = 0;
575 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::CALENDAR_MONTH, month);
576 calendar->SetMonth(month);
577
578 uint8_t day = 0;
579 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::CALENDAR_DAY, day);
580 calendar->SetDay(day);
581
582 uint8_t hour = 0;
583 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::CALENDAR_HOUR, hour);
584 calendar->SetHour(hour);
585
586 uint8_t minute = 0;
587 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderTable::CALENDAR_MINUTE, minute);
588 calendar->SetMinute(minute);
589 }
590 }
591
RecoverTime(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)592 void ReminderCalendarStrategy::RecoverTime(sptr<ReminderRequest>& reminder,
593 const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
594 {
595 if (reminder->GetReminderType() == ReminderRequest::ReminderType::CALENDAR) {
596 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
597
598 uint16_t firstDesignateYear = 0;
599 ReminderStrategy::GetRdbValue<uint16_t>(resultSet, ReminderCalendarTable::FIRST_DESIGNATE_YEAR,
600 firstDesignateYear);
601 calendar->SetFirstDesignateYear(firstDesignateYear);
602
603 uint8_t firstDesignateMonth = 0;
604 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderCalendarTable::FIRST_DESIGNATE_MONTH,
605 firstDesignateMonth);
606 calendar->SetFirstDesignageMonth(firstDesignateMonth);
607
608 uint8_t firstDesignateDay = 0;
609 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderCalendarTable::FIRST_DESIGNATE_DAY,
610 firstDesignateDay);
611 calendar->SetFirstDesignateDay(firstDesignateDay);
612
613 uint64_t dateTime = 0;
614 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderCalendarTable::CALENDAR_DATE_TIME, dateTime);
615 calendar->SetDateTime(dateTime);
616
617 uint64_t endDateTime = 0;
618 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderCalendarTable::CALENDAR_END_DATE_TIME, endDateTime);
619 if (endDateTime != 0 && endDateTime >= dateTime) {
620 calendar->SetEndDateTime(endDateTime);
621 } else {
622 calendar->SetEndDateTime(dateTime);
623 }
624
625 uint64_t lastStartDateTime = 0;
626 ReminderStrategy::GetRdbValue<uint64_t>(resultSet, ReminderCalendarTable::CALENDAR_LAST_DATE_TIME,
627 lastStartDateTime);
628 if (lastStartDateTime == 0) {
629 calendar->SetLastStartDateTime(dateTime);
630 } else {
631 calendar->SetLastStartDateTime(lastStartDateTime);
632 }
633 }
634 }
635
RecoverFromDb(sptr<ReminderRequest> & reminder,const std::shared_ptr<NativeRdb::ResultSet> & baseResult,const std::shared_ptr<NativeRdb::ResultSet> & resultSet)636 void ReminderCalendarStrategy::RecoverFromDb(sptr<ReminderRequest>& reminder,
637 const std::shared_ptr<NativeRdb::ResultSet>& baseResult, const std::shared_ptr<NativeRdb::ResultSet>& resultSet)
638 {
639 if (resultSet == nullptr || reminder == nullptr || baseResult == nullptr) {
640 ANSR_LOGE("ResultSet is null or reminder is null");
641 return;
642 }
643 ReminderStrategy::RecoverFromDb(reminder, baseResult);
644 ReminderCalendarStrategy::RecoverTime(reminder, resultSet);
645 if (reminder != nullptr && reminder->GetReminderType() == ReminderRequest::ReminderType::CALENDAR) {
646 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
647
648 uint32_t repeatDay = 0;
649 ReminderStrategy::GetRdbValue<uint32_t>(resultSet, ReminderCalendarTable::REPEAT_DAYS, repeatDay);
650 calendar->SetRepeatDay(repeatDay);
651
652 uint16_t repeatMonth = 0;
653 ReminderStrategy::GetRdbValue<uint16_t>(resultSet, ReminderCalendarTable::REPEAT_MONTHS, repeatMonth);
654 calendar->SetRepeatMonth(repeatMonth);
655
656 uint8_t repeatDaysOfWeek = 0;
657 ReminderStrategy::GetRdbValue<uint8_t>(resultSet, ReminderCalendarTable::REPEAT_DAYS_OF_WEEK, repeatDaysOfWeek);
658 calendar->SetRepeatDaysOfWeek(repeatDaysOfWeek);
659
660 std::string rruleWantAgent;
661 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderCalendarTable::RRULE_WANT_AGENT, rruleWantAgent);
662 calendar->DeserializationRRule(rruleWantAgent);
663
664 std::string excludeDates;
665 ReminderStrategy::GetRdbValue<std::string>(resultSet, ReminderCalendarTable::EXCLUDE_DATES, excludeDates);
666 calendar->DeserializationExcludeDates(excludeDates);
667 }
668 }
669 }
670 }