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