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