修改了通知相关的功能,能够正常通知了。

This commit is contained in:
2026-09-13 23:35:52 +08:00
parent e62416e5ce
commit 6899a5074b
10 changed files with 752 additions and 62 deletions
+24
View File
@@ -14,6 +14,7 @@ export class AppSettings {
private static readonly KEY_BACKUP_KEY: string = 'sys_backup_cal_key'; // 备份目标 DAV 日历本
private static readonly KEY_MANUAL_READONLY: string = 'manual_readonly_keys'; // 手动标记只读的 calKey
private static readonly KEY_MUTED_REMINDER: string = 'muted_reminder_keys'; // 提醒静音的 calKey
private static readonly KEY_REMINDER_TICK: string = 'reminder_tick'; // 应用内提醒上次检查时间戳
private static readonly KEY_FULL_REFETCH: string = 'full_refetch_done'; // 一次性全量重拉已完成
/**
@@ -114,6 +115,29 @@ export class AppSettings {
}
}
/** 应用内提醒模式的上次检查时间戳(毫秒,0 = 未初始化) */
static async getReminderTick(context: common.Context): Promise<number> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
return await store.get(AppSettings.KEY_REMINDER_TICK, 0) as number;
} catch (err) {
return 0;
}
}
static async setReminderTick(context: common.Context, tick: number): Promise<void> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
await store.put(AppSettings.KEY_REMINDER_TICK, tick);
await store.flush();
} catch (err) {
const e = err as BusinessError;
console.error(`保存提醒检查时间戳失败: ${e.message}`);
}
}
/** 系统日历模式:display = 仅混合显示;backup = 本地系统日程备份到选定 CalDAV 日历本 */
static async getSysCalMode(context: common.Context): Promise<string> {
try {
+39 -4
View File
@@ -25,7 +25,8 @@ export class LocalEvent {
completed: boolean = false; // 待办是否已完成(STATUS:COMPLETED
rrule: string = ''; // 原始 RRULE(空 = 非重复);显示时按规则展开多次发生
exdate: string = ''; // 原始 EXDATE 排除日期,分号分隔
reminder: number = 0; // 提醒提前分钟数(来自 VALARM0 = 不提醒
reminder: number = 0; // 提醒提前分钟数(第一个提醒,兼容旧字段)0 = 不提醒
reminders: number[] = []; // 全部提醒提前分钟数(多选),按添加顺序
}
/** 远端事件条目(REPORT 解析结果) */
@@ -43,7 +44,8 @@ export class RemoteEvent {
completed: boolean = false; // VTODO STATUS:COMPLETED
rrule: string = ''; // 原始 RRULE
exdate: string = ''; // 原始 EXDATE(分号分隔)
reminder: number = 0; // 提醒提前分钟数(VALARM
reminder: number = 0; // 提醒提前分钟数(第一个提醒,兼容旧字段
reminders: number[] = []; // 全部提醒提前分钟数(多选)
}
export class EventDb {
@@ -97,10 +99,31 @@ export class EventDb {
} catch (err) {
// 列已存在
}
try {
await store.executeSql("ALTER TABLE events ADD COLUMN reminders TEXT DEFAULT ''");
} catch (err) {
// 列已存在
}
EventDb.db = store;
return store;
}
/** 提醒数组规范化:去掉 0/非法值并去重升序 */
static normalizeReminders(list: number[]): number[] {
const set = new Set<number>();
for (const n of list) {
if (n > 0) {
set.add(n);
}
}
return Array.from(set).sort((a: number, b: number): number => a - b);
}
/** 提醒数组比较键(规范化后逗号连接,用于增量比对) */
static remKey(list: number[]): string {
return EventDb.normalizeReminders(list).join(',');
}
private static fromRow(rs: relationalStore.ResultSet): LocalEvent {
const e = new LocalEvent();
e.id = rs.getLong(rs.getColumnIndex('id'));
@@ -124,6 +147,14 @@ export class EventDb {
e.rrule = rs.getString(rs.getColumnIndex('rrule'));
e.exdate = rs.getString(rs.getColumnIndex('exdate'));
e.reminder = rs.getLong(rs.getColumnIndex('reminder'));
// 多提醒(逗号分隔分钟数);旧数据无该列时回退单提醒
const remStr: string = rs.getString(rs.getColumnIndex('reminders'));
if (remStr !== '') {
e.reminders = remStr.split(',').map((s: string): number => Number(s))
.filter((n: number): boolean => !Number.isNaN(n) && n > 0);
} else if (e.reminder > 0) {
e.reminders = [e.reminder];
}
return e;
}
@@ -147,7 +178,8 @@ export class EventDb {
'completed': e.completed ? 1 : 0,
'rrule': e.rrule,
'exdate': e.exdate,
'reminder': e.reminder
'reminder': e.reminders.length > 0 ? e.reminders[0] : 0,
'reminders': e.reminders.map((n: number): string => String(n)).join(',')
};
return bucket;
}
@@ -365,10 +397,12 @@ export class EventDb {
e.rrule = r.rrule;
e.exdate = r.exdate;
e.reminder = r.reminder;
e.reminders = r.reminders;
await store.insert('events', EventDb.toBucket(e));
added++;
} else if (found.etag !== r.etag || found.rrule !== r.rrule || found.exdate !== r.exdate
|| found.reminder !== r.reminder || found.recurring !== r.recurring) {
|| found.reminder !== r.reminder || found.recurring !== r.recurring
|| EventDb.remKey(found.reminders) !== EventDb.remKey(r.reminders)) {
// 更新(rrule/exdate/recurring 变化也更新,兼容老数据回填)
found.title = r.title;
found.description = r.description;
@@ -385,6 +419,7 @@ export class EventDb {
found.rrule = r.rrule;
found.exdate = r.exdate;
found.reminder = r.reminder;
found.reminders = r.reminders;
const up = new relationalStore.RdbPredicates('events');
up.equalTo('id', found.id);
await store.update(EventDb.toBucket(found), up);
+23 -3
View File
@@ -16,7 +16,8 @@ class ParsedEvent {
inAlarm: boolean = false; // 是否处于 VALARM 子组件内(内部属性不参与解析)
rrule: string = ''; // 原始 RRULE 值
exdates: string[] = []; // 原始 EXDATE 值列表
reminder: number = 0; // 提醒提前分钟数(来自 VALARM TRIGGER0 = 不提醒)
reminder: number = 0; // 提醒提前分钟数(第一个 VALARM0 = 不提醒)
reminders: number[] = []; // 全部提醒提前分钟数(多 VALARM)
}
/** iCal 时间解析结果 */
@@ -71,7 +72,13 @@ export class IcsUtil {
const av: string = line.substring(ac + 1).trim();
const an: string = ap.split(';')[0].toUpperCase();
if (an === 'TRIGGER') {
current.reminder = IcsUtil.triggerMinutes(av, ap);
const m: number = IcsUtil.triggerMinutes(av, ap);
if (m > 0) {
current.reminders.push(m);
if (current.reminder === 0) {
current.reminder = m; // 第一个提醒作为主提醒(兼容旧字段)
}
}
}
}
continue;
@@ -134,6 +141,7 @@ export class IcsUtil {
r.rrule = p.rrule;
r.exdate = p.exdates.join(';');
r.reminder = p.reminder;
r.reminders = p.reminders;
return r;
});
}
@@ -244,11 +252,23 @@ export class IcsUtil {
`SUMMARY:${IcsUtil.escape(e.title)}\r\n` +
(e.location !== '' ? `LOCATION:${IcsUtil.escape(e.location)}\r\n` : '') +
(e.description !== '' ? `DESCRIPTION:${IcsUtil.escape(e.description)}\r\n` : '') +
(e.reminder > 0 ? IcsUtil.valarm(e.reminder) : '') +
IcsUtil.valarms(e.reminders.length > 0 ? e.reminders
: (e.reminder > 0 ? [e.reminder] : [])) +
'END:VEVENT\r\n' +
'END:VCALENDAR\r\n';
}
/** 由提醒分钟数组生成多个 VALARM(已规范化去重) */
private static valarms(minutes: number[]): string {
let out: string = '';
for (const m of minutes) {
if (m > 0) {
out += IcsUtil.valarm(m);
}
}
return out;
}
/** 由提前分钟数生成 VALARM(TRIGGER 负时长 = 提前触发) */
private static valarm(minutes: number): string {
let trigger: string;
+89 -7
View File
@@ -1,25 +1,107 @@
// entry/src/main/ets/common/LogUtil.ets
// 日志功能已按需求移除:保留空实现以兼容既有调用点(不写文件、不再缓冲)
// 同步日志:写入应用 filesDir/sync.log(含时间戳),超 512KB 自动截断保留后半。
// 设置页「同步日志」卡片可查看/复制/清空,方便真机测试时诊断同步与提醒问题。
import { common } from '@kit.AbilityKit';
import { fileIo as fs } from '@kit.CoreFileKit';
import { util } from '@kit.ArkTS';
import { BusinessError } from '@kit.BasicServicesKit';
export class LogUtil {
static logFilePath(): string {
return '';
}
private static path: string = '';
private static readonly MAX_BYTES: number = 512 * 1024;
/** 空实现(日志功能已移除) */
static init(context: common.Context): void {
try {
LogUtil.path = `${context.filesDir}/sync.log`;
} catch (err) {
LogUtil.path = '';
}
}
/** 仅输出到 consolehilog),不再写文件 */
static logFilePath(): string {
return LogUtil.path;
}
/** 写一行日志:console + 文件(文件失败静默,不影响业务) */
static write(msg: string): void {
console.info(`SyncLog ${msg}`);
if (LogUtil.path === '') {
return;
}
try {
const d = new Date();
const p = (n: number): string => n < 10 ? '0' + n : String(n);
const ts: string = `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}` +
` ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
// 超限截断:保留最后 256KB
try {
const st: fs.Stat = fs.statSync(LogUtil.path);
if (st.size > LogUtil.MAX_BYTES) {
LogUtil.truncate();
}
} catch (err) {
// 文件不存在属正常,直接创建写入
}
const file: fs.File = fs.openSync(LogUtil.path,
fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.APPEND);
fs.writeSync(file.fd, `[${ts}] ${msg}\n`);
fs.closeSync(file.fd);
} catch (err) {
// 写日志失败不影响业务
}
}
/** 截断:只保留文件末尾 256KB */
private static truncate(): void {
try {
const keep: number = 256 * 1024;
const st: fs.Stat = fs.statSync(LogUtil.path);
const size: number = Math.min(st.size, keep);
const file = fs.openSync(LogUtil.path, fs.OpenMode.READ_ONLY);
const buf: ArrayBuffer = new ArrayBuffer(size);
fs.readSync(file.fd, buf, { offset: st.size - size });
fs.closeSync(file.fd);
const out = fs.openSync(LogUtil.path,
fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC);
fs.writeSync(out.fd, `…(日志过长,已截断保留末尾)\n`);
fs.writeSync(out.fd, new Uint8Array(buf));
fs.closeSync(out.fd);
} catch (err) {
// 截断失败忽略,下次再试
}
}
static readAll(context: common.Context): string {
return '(日志功能已移除)';
try {
if (LogUtil.path === '') {
LogUtil.init(context);
}
if (LogUtil.path === '') {
return '(无法确定日志路径)';
}
const st: fs.Stat = fs.statSync(LogUtil.path);
if (st.size === 0) {
return '(日志为空)';
}
const file = fs.openSync(LogUtil.path, fs.OpenMode.READ_ONLY);
const buf: ArrayBuffer = new ArrayBuffer(st.size);
fs.readSync(file.fd, buf);
fs.closeSync(file.fd);
const decoder: util.TextDecoder = util.TextDecoder.create('utf-8');
return decoder.decodeToString(new Uint8Array(buf));
} catch (err) {
return `(读取日志失败: ${(err as BusinessError).message})`;
}
}
static clear(context: common.Context): void {
try {
if (LogUtil.path === '') {
LogUtil.init(context);
}
fs.unlinkSync(LogUtil.path);
} catch (err) {
// 文件不存在等,忽略
}
}
}
+292 -13
View File
@@ -1,27 +1,136 @@
// entry/src/main/ets/common/ReminderService.ets
// 日程提醒:基于后台代理提醒(reminderAgentManager
// 在日程开始前 N 分钟(来自服务器 VALARM TRIGGER)发系统通知,可右滑删除
// 日程提醒,双模式:
// 1) 系统代理提醒(reminderAgentManager):需要华为审批的"代理提醒使用权限",
// 未申请的普通应用配额为 0(发布报 1700002 且池内为 0
// 2) 应用内通知(notificationManager):配额为 0 时的降级方案。
// 依赖应用进程存活(前台或"后台持续同步"长时任务),由自动同步定时器驱动,
// 每次检查把"提醒时刻刚好已到"的日程用本地通知发出。
import { reminderAgentManager } from '@kit.BackgroundTasksKit';
import { notificationManager } from '@kit.NotificationKit';
import { common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { EventDb, LocalEvent } from './EventDb';
import { AppSettings } from './AppSettings';
import { AccountStore } from './AccountStore';
import { LogUtil } from './LogUtil';
export class ReminderService {
private static readonly MAX_REMINDERS: number = 30; // 系统对单应用代理提醒数量有限制
// 系统对单应用代理提醒上限 30 条,留 5 个余量给测试提醒等临时请求
private static readonly MAX_REMINDERS: number = 25;
private static readonly WINDOW: number = 7 * 86400000; // 只排未来 7 天
/** 全量重建提醒:先取消本应用全部代理提醒,再按当前数据重新发布 */
static async refreshReminders(context: common.Context): Promise<void> {
/** 代理提醒可用性:null=未探测(每次进程启动重新探测),false=配额为0(走应用内通知),true=可用 */
static agentAvailable: boolean | null = null;
/** calKey → 日历本名称缓存(通知文案用),60 秒刷新一次 */
private static calNameCache: Map<string, string> = new Map();
private static calNameLoadedAt: number = 0;
/** 日历本名称(通知文案用):缓存 60 秒,'local' = 本机日历 */
private static async calName(context: common.Context, calKey: string): Promise<string> {
if (Date.now() - ReminderService.calNameLoadedAt > 60000
|| ReminderService.calNameCache.size === 0) {
const map: Map<string, string> = new Map();
map.set('local', '本机日历');
try {
const accounts = await AccountStore.loadAll(context);
for (const acc of accounts) {
for (let i: number = 0; i < acc.calendarHrefs.length; i++) {
const bookName: string = i < acc.calendarNames.length
? acc.calendarNames[i] : `日历本${i + 1}`;
map.set(`${acc.id}_${i}`, `${acc.name}·${bookName}`);
}
}
} catch (err) {
// 读取失败用旧缓存
}
ReminderService.calNameCache = map;
ReminderService.calNameLoadedAt = Date.now();
}
const name: string | undefined = ReminderService.calNameCache.get(calKey);
return name !== undefined ? name : '日历';
}
private static delay(ms: number): Promise<void> {
return new Promise<void>((resolve: () => void) => {
setTimeout(resolve, ms);
});
}
/** 当前系统里本应用的有效提醒条数 */
private static async poolCount(): Promise<number> {
try {
const all = await reminderAgentManager.getValidReminders();
return all.length;
} catch (err) {
return -1;
}
}
/**
* 发布单条代理提醒,1700002(池满/配额0)时清空后等待释放再重试,最多 3 轮。
* 3 轮后仍满且池内为 0 → 判定配额为 0(需华为邮件申请权限),抛出标记错误。
*/
private static async publishWithRetry(request: reminderAgentManager.ReminderRequestCalendar): Promise<void> {
try {
await reminderAgentManager.publishReminder(request);
ReminderService.agentAvailable = true;
return;
} catch (err) {
const e = err as BusinessError;
if (e.code !== 1700002) {
// ArkTS 只允许抛 Error:错误码编入消息,调用方从 message 解析
throw new Error(`${e.code}:${e.message}`);
}
}
for (let attempt: number = 1; attempt <= 3; attempt++) {
// 已触发的代理提醒会残留为通知,一并清理
try {
await notificationManager.cancelAll();
} catch (err) {
// 忽略
}
await reminderAgentManager.cancelAllReminders();
await ReminderService.delay(1500);
const remain: number = await ReminderService.poolCount();
LogUtil.write(`提醒池满(第 ${attempt} 次腾位):清空后剩余 ${remain} 条,重试发布`);
try {
await reminderAgentManager.publishReminder(request);
ReminderService.agentAvailable = true;
return;
} catch (err) {
const e = err as BusinessError;
if (e.code !== 1700002) {
throw new Error(`${e.code}:${e.message}`);
}
}
}
throw new Error('1700002:提醒池腾位 3 轮后仍满');
}
/** 判定"配额为 0"1700002 且系统内有效提醒为 0(没有超额却报超额 = 没有配额) */
private static async isQuotaZero(): Promise<boolean> {
const remain: number = await ReminderService.poolCount();
return remain <= 0;
}
/** 全量重建代理提醒(仅在代理提醒可用时调用)。返回发布条数 */
static async refreshReminders(context: common.Context): Promise<number> {
let published: number = 0;
if (ReminderService.agentAvailable === false) {
return 0; // 应用内通知模式接管,不再请求代理提醒
}
try {
await reminderAgentManager.cancelAllReminders();
const before: number = await ReminderService.poolCount();
if (before > 0) {
LogUtil.write(`取消全部提醒后系统仍剩 ${before} 条`);
}
const now: number = Date.now();
const rows: LocalEvent[] =
await EventDb.queryRemindable(context, now, now + ReminderService.WINDOW);
// 提醒静音的日历本(如别人分享的本):其中所有日程都不再提醒
const muted: string[] = await AppSettings.getMutedReminderKeys(context);
let published: number = 0;
for (const e of rows) {
if (muted.includes(e.calKey)) {
continue;
@@ -29,12 +138,19 @@ export class ReminderService {
if (published >= ReminderService.MAX_REMINDERS) {
break;
}
const remindAt: number = e.startTime - e.reminder * 60000;
// 多提醒:每个提前量各发一条(含旧单提醒数据回退)
const rems: number[] = e.reminders.length > 0 ? e.reminders
: (e.reminder > 0 ? [e.reminder] : []);
for (const rem of rems) {
if (published >= ReminderService.MAX_REMINDERS) {
break;
}
const remindAt: number = e.startTime - rem * 60000;
if (remindAt <= now) {
continue; // 提醒时间已过
}
const d = new Date(remindAt);
const startTimeText: string = ReminderService.fmt(e.startTime);
const calName: string = await ReminderService.calName(context, e.calKey);
const request: reminderAgentManager.ReminderRequestCalendar = {
reminderType: reminderAgentManager.ReminderType.REMINDER_TYPE_CALENDAR,
dateTime: {
@@ -46,20 +162,183 @@ export class ReminderService {
second: 0
},
title: '日程提醒',
content: `「${e.title}」将于 ${startTimeText} 开始(提前 ${e.reminder} 分钟`,
notificationId: e.id % 100000,
content: `「${calName}」中的「${e.title}」将在 ${rem} 分钟后开始`,
notificationId: (e.id * 10 + rem) % 100000,
expiredContent: '该日程已开始',
ringDuration: 5,
snoozeTimes: 0,
timeInterval: 0
};
await reminderAgentManager.publishReminder(request);
await ReminderService.publishWithRetry(request);
published++;
}
LogUtil.write(`提醒刷新完成:发布 ${published} 个提醒(窗口 7 天,静音日历本 ${muted.length} 个)`);
}
const after: number = await ReminderService.poolCount();
LogUtil.write(`提醒刷新完成:发布 ${published} 个提醒(窗口 7 天,静音日历本 ${muted.length} 个,池内现有 ${after} 条)`);
return published;
} catch (err) {
const e = err as Error;
if (e.message.startsWith('1700002') && await ReminderService.isQuotaZero()) {
// 配额为 0:普通应用未获代理提醒权限,降级为应用内通知模式
ReminderService.agentAvailable = false;
await AppSettings.setReminderTick(context, Date.now());
LogUtil.write('代理提醒配额为 0(需向华为邮件申请权限),已自动切换为应用内通知模式');
return 0;
}
LogUtil.write(`提醒刷新失败: ${e.message}`);
return published;
}
}
/**
* 应用内提醒检查(降级模式):由自动同步定时器高频调用。
* 把"提醒时刻落在上次检查~现在之间"的日程用本地通知发出。
* App 进程被杀期间的提醒会错过(超过 2 分钟不补发),长时任务可避免。
*/
static async tickReminders(context: common.Context): Promise<number> {
if (ReminderService.agentAvailable !== false) {
return 0; // 代理提醒可用或未判定,不需要降级
}
try {
const now: number = Date.now();
const last: number = await AppSettings.getReminderTick(context);
if (last <= 0) {
await AppSettings.setReminderTick(context, now); // 首次运行:只记基线不补发
return 0;
}
const from: number = Math.max(last, now - 2 * 60000); // 最多补发 2 分钟内的错过提醒
await AppSettings.setReminderTick(context, now);
const rows: LocalEvent[] =
await EventDb.queryRemindable(context, now, now + ReminderService.WINDOW);
const muted: string[] = await AppSettings.getMutedReminderKeys(context);
let fired: number = 0;
for (const e of rows) {
if (muted.includes(e.calKey)) {
continue;
}
const rems: number[] = e.reminders.length > 0 ? e.reminders
: (e.reminder > 0 ? [e.reminder] : []);
for (const rem of rems) {
const remindAt: number = e.startTime - rem * 60000;
if (remindAt <= from || remindAt > now) {
continue; // 不在本次检查窗口内
}
const calName: string = await ReminderService.calName(context, e.calKey);
const minLeft: number = Math.max(1,
Math.ceil((e.startTime - Date.now()) / 60000));
const fired2: number = await ReminderService.notifyNow(
'日程提醒', `「${calName}」中的「${e.title}」将在 ${minLeft} 分钟后开始`,
(e.id * 10 + rem) % 100000);
if (fired2 === 0) {
fired++;
}
}
}
if (fired > 0) {
LogUtil.write(`应用内提醒:本次发出 ${fired} 条到点提醒`);
}
return fired;
} catch (err) {
const e = err as Error;
LogUtil.write(`应用内提醒检查失败: ${e.message}`);
return 0;
}
}
/** 日历本通知渠道(SOCIAL_COMMUNICATION 默认横幅+锁屏+响铃振动),只注册一次 */
private static slotReady: boolean = false;
private static async ensureSlot(): Promise<void> {
if (ReminderService.slotReady) {
return;
}
try {
// 本 SDK 无锁屏可见性 API(已废弃),锁屏显示由系统"锁屏通知"设置 + 渠道默认行为决定
await notificationManager.addSlot(notificationManager.SlotType.SOCIAL_COMMUNICATION);
} catch (err) {
// 渠道已存在等情况忽略
}
ReminderService.slotReady = true;
}
/** 立即发一条本地通知。返回 0 表示成功 */
private static async notifyNow(title: string, text: string, id: number): Promise<number> {
await ReminderService.ensureSlot();
try {
const request: notificationManager.NotificationRequest = {
id: id,
notificationSlotType: notificationManager.SlotType.SOCIAL_COMMUNICATION,
content: {
notificationContentType: notificationManager.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
normal: {
title: title,
text: text,
additionalText: ''
}
}
};
await notificationManager.publish(request);
return 0;
} catch (err) {
const e = err as BusinessError;
LogUtil.write(`提醒刷新失败: ${e.code} - ${e.message}`);
LogUtil.write(`本地通知发布失败: ${e.code} - ${e.message}`);
return -1;
}
}
/** 测试入口:代理可用时发 1 分钟后的代理提醒;降级模式发立即本地通知 */
static async publishTestReminder(context: common.Context): Promise<string> {
if (ReminderService.agentAvailable === false) {
const r: number = await ReminderService.notifyNow(
'测试通知(应用内模式)', '如果你看到这条通知,说明应用内提醒链路正常', 99998);
return r === 0
? '已发出测试通知(应用内模式:代理提醒配额为 0,由 App 进程在提醒时刻发通知)'
: '本地通知发布失败,详见日志';
}
// request 构造放在 try 外:腾位重试也要用到
const t: number = Date.now() + 60 * 1000;
const d = new Date(t);
const request: reminderAgentManager.ReminderRequestCalendar = {
reminderType: reminderAgentManager.ReminderType.REMINDER_TYPE_CALENDAR,
dateTime: {
year: d.getFullYear(),
month: d.getMonth() + 1,
day: d.getDate(),
hour: d.getHours(),
minute: d.getMinutes(),
second: 0
},
title: '测试提醒',
content: '这是一条测试提醒:如果你看到它,说明提醒链路正常',
notificationId: 99999,
expiredContent: '测试提醒已过期',
ringDuration: 5,
snoozeTimes: 0,
timeInterval: 0
};
const before: number = await ReminderService.poolCount();
LogUtil.write(`测试提醒发布前池内提醒 ${before} 条`);
try {
await ReminderService.publishWithRetry(request);
LogUtil.write('测试提醒已发布:1 分钟后应弹出通知');
return `已发布(发布前池内 ${before} 条),1 分钟后应弹出通知`;
} catch (err) {
const e = err as Error;
if (e.message.startsWith('1700002') && await ReminderService.isQuotaZero()) {
ReminderService.agentAvailable = false;
await AppSettings.setReminderTick(context, Date.now());
LogUtil.write('代理提醒配额为 0(需向华为邮件申请权限),已切换为应用内通知模式');
const r: number = await ReminderService.notifyNow(
'测试通知(应用内模式)', '如果你看到这条通知,说明应用内提醒链路正常', 99998);
return r === 0
? '代理提醒配额为 0(需邮件向华为申请),已切换为应用内通知模式并发出测试通知'
: '代理提醒配额为 0,已切换应用内模式,但测试通知发布失败(详见日志)';
}
LogUtil.write(`测试提醒发布失败: ${e.message}`);
const sep: number = e.message.indexOf(':');
return sep > 0
? `发布失败:错误码 ${e.message.substring(0, sep)}${e.message.substring(sep + 1)}`
: `发布失败:${e.message}`;
}
}
+2 -1
View File
@@ -277,6 +277,7 @@ export class SyncEngine {
r.rrule = e.rrule;
r.exdate = e.exdate;
r.reminder = e.reminder;
r.reminders = e.reminders.slice();
return r;
}
@@ -319,7 +320,7 @@ export class SyncEngine {
const ics: string = IcsUtil.build(e);
const etag: string = await DavClient.putEvent(url, auth, ics);
await EventDb.clearDirty(context, e.id, etag);
LogUtil.write(`推送保存「${e.title}」→ ${url}${ics.length} 字节)`);
LogUtil.write(`推送保存「${e.title}」→ ${url}${ics.length} 字节,提醒=${e.reminders.map((n: number): string => String(n)).join('/')}分钟,VALARM=${ics.toUpperCase().includes('BEGIN:VALARM') ? '有' : '无'}`);
}
}
}
@@ -4,12 +4,16 @@ import { window } from '@kit.ArkUI';
import { notificationManager } from '@kit.NotificationKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { BackgroundSyncService } from '../common/BackgroundSyncService';
import { LogUtil } from '../common/LogUtil';
const DOMAIN = 0x0000;
export default class EntryAbility extends UIAbility {
onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
hilog.info(DOMAIN, 'testTag', '%{public}s', 'Ability onCreate');
// 文件日志初始化:所有页面的同步日志统一写入 filesDir/sync.log
LogUtil.init(this.context);
LogUtil.write('---- App 启动 ----');
// 后台同步:注册延迟任务兜底 + 按设置恢复长时任务
BackgroundSyncService.initOnLaunch(this.context);
// 申请通知权限:日程提醒、后台同步常驻通知都依赖它(系统只弹一次授权框)
+58 -14
View File
@@ -8,6 +8,8 @@ import { EventDb, LocalEvent } from '../common/EventDb';
import { AppSettings } from '../common/AppSettings';
import { DavClient } from '../common/DavClient';
import { SyncEngine } from '../common/SyncEngine';
import { ReminderService } from '../common/ReminderService';
import { LogUtil } from '../common/LogUtil';
/** 可选的日历本 */
class BookChoice {
@@ -32,7 +34,7 @@ struct EventEditPage {
@State statusMsg: string = '';
@State isExisting: boolean = false;
@State repeatMode: string = 'none'; // none|daily|workday|weekly|monthly|yearly|custom
@State reminderMin: number = 0; // 提前提醒分钟数0 = 不提醒
@State reminderList: number[] = []; // 提前提醒分钟数(多选),空 = 不提醒
@State pickerShow: boolean = false; // 开始/结束时间选择底部弹层(日期+时间一次选完)
@State pickerIsEnd: boolean = false;
@State pickDate: Date = new Date();
@@ -77,16 +79,18 @@ struct EventEditPage {
this.endMs = loaded.endTime;
this.chosenKey = loaded.calKey;
this.repeatMode = loaded.rrule !== '' ? this.modeFromRrule(loaded.rrule) : 'none';
this.reminderMin = loaded.reminder;
this.reminderList = loaded.reminders.length > 0 ? loaded.reminders
: (loaded.reminder > 0 ? [loaded.reminder] : []);
return;
}
}
// 新建:默认时间 = 所选日期 9:00-10:00
// 新建:日期取所选日(未选则今天),时间取当前时刻;结束 = 开始 + 1 小时
const base: number = AppStorage.get<number>('pendingEventDate') ?? Date.now();
const dayStart = new Date(new Date(base).getFullYear(), new Date(base).getMonth(),
new Date(base).getDate()).getTime();
this.startMs = dayStart + 9 * 3600000;
this.endMs = dayStart + 10 * 3600000;
const now = new Date();
this.startMs = dayStart + now.getHours() * 3600000 + now.getMinutes() * 60000;
this.endMs = this.startMs + 3600000;
if (choices.length > 0) {
this.chosenKey = choices[0].calKey;
}
@@ -179,9 +183,9 @@ struct EventEditPage {
// 全天日程的结束存为"当天 23:59:59.999"(排他日期前 1 毫秒)
this.endMs = this.allDay ? picked + 86399999 : picked;
} else {
const dur: number = Math.max(0, this.endMs - this.startMs);
// 设定开始时间后,结束时间自动跟随 = 开始 + 1 小时
this.startMs = picked;
this.endMs = this.allDay ? picked + 86399999 : picked + dur;
this.endMs = this.allDay ? picked + 86399999 : picked + 3600000;
}
}
@@ -246,7 +250,8 @@ struct EventEditPage {
e.rrule = this.rruleForMode(this.repeatMode);
}
e.recurring = e.rrule !== '';
e.reminder = this.reminderMin;
e.reminders = EventDb.normalizeReminders(this.reminderList);
e.reminder = e.reminders.length > 0 ? e.reminders[0] : 0;
if (isNew) {
e.uid = `syncal-${Date.now()}-${Math.floor(Math.random() * 1000000)}`;
e.remotePath = encodeURIComponent(e.uid) + '.ics';
@@ -265,11 +270,18 @@ struct EventEditPage {
} else {
await SyncEngine.settleLocalEvents(context);
}
LogUtil.write(`本地保存日程「${e.title}」提醒=${e.reminders.join('/')}分钟 重复=${e.rrule === '' ? '否' : e.rrule}`);
// 立即刷新提醒(不等下一轮同步),保证刚保存的提醒马上生效
try {
await ReminderService.refreshReminders(context as common.UIAbilityContext);
} catch (err) {
// 刷新失败不影响保存
}
this.getUIContext().getPromptAction().showToast({ message: '日程已保存' });
router.back();
} catch (err) {
const ex = err as BusinessError;
console.error(`保存日程失败: ${ex.message}`);
LogUtil.write(`保存日程流程失败(数据已存本地待重试):${ex.message}`);
this.statusMsg = `保存失败:${ex.message}(已保存到本地,稍后同步会重试)`;
// 数据仍在本地且带 dirty 标记,不会丢
router.back();
@@ -302,6 +314,13 @@ struct EventEditPage {
} else {
await SyncEngine.settleLocalEvents(context);
}
LogUtil.write(`本地删除日程「${this.event?.title ?? ''}」`);
// 立即刷新提醒(取消已发布但日程已删的提醒)
try {
await ReminderService.refreshReminders(context as common.UIAbilityContext);
} catch (err) {
// 刷新失败不影响删除
}
this.getUIContext().getPromptAction().showToast({ message: '日程已删除' });
router.back();
} catch (err) {
@@ -407,7 +426,7 @@ struct EventEditPage {
// 提醒
Column({ space: 8 }) {
Text('提醒')
Text('提醒(可多选)')
.fontSize(14)
.fontColor($r('app.color.text_secondary'))
Flex({ wrap: FlexWrap.Wrap, justifyContent: FlexAlign.Start }) {
@@ -541,7 +560,8 @@ struct EventEditPage {
.width('100%')
.padding({ left: 8, right: 8, top: 10, bottom: 10 })
.onClick(() => {
this.openPicker(isStart);
// 注意:timeRow 的参数是 isStartopenPicker 的参数是 isEnd,语义相反必须取反
this.openPicker(!isStart);
})
}
@@ -560,18 +580,42 @@ struct EventEditPage {
})
}
/** 提醒 chip 是否选中:0 = 不提醒(列表为空时选中);其余按是否已选 */
private chipOn(minutes: number): boolean {
if (minutes === 0) {
return this.reminderList.length === 0;
}
return this.reminderList.includes(minutes);
}
/** 切换提醒:0 = 清空全部;其余多选切换 */
private toggleReminder(minutes: number): void {
if (minutes === 0) {
this.reminderList = [];
return;
}
const list: number[] = [...this.reminderList];
const idx: number = list.indexOf(minutes);
if (idx >= 0) {
list.splice(idx, 1);
} else {
list.push(minutes);
}
this.reminderList = list;
}
@Builder
reminderChip(minutes: number) {
Text(this.reminderLabel(minutes))
.fontSize(12)
.fontColor(this.reminderMin === minutes
.fontColor(this.chipOn(minutes)
? $r('app.color.button_text') : $r('app.color.text_primary'))
.padding({ left: 10, right: 10, top: 6, bottom: 6 })
.borderRadius(14)
.margin({ right: 8, bottom: 8 })
.backgroundColor(this.reminderMin === minutes ? $r('app.color.brand') : $r('app.color.chip_off_bg'))
.backgroundColor(this.chipOn(minutes) ? $r('app.color.brand') : $r('app.color.chip_off_bg'))
.onClick(() => {
this.reminderMin = minutes;
this.toggleReminder(minutes);
})
}
+6
View File
@@ -181,12 +181,18 @@ struct Index {
});
}
this.autoSyncTimer = setInterval((): void => {
// 应用内提醒模式(代理提醒配额为 0 的降级):每 15 秒检查到点的提醒
const tickCtx = this.getUIContext().getHostContext();
if (tickCtx !== undefined && !this.syncing) {
ReminderService.tickReminders(tickCtx as common.UIAbilityContext);
}
const minutes: number = AppStorage.get<number>('syncIntervalMinutes') ?? 1;
if (Date.now() - this.lastSyncTime < minutes * 60000) {
return; // 未到设置的同步间隔
}
if (!this.syncing && this.accounts.length > 0) {
this.lastSyncTime = Date.now();
LogUtil.write(`自动同步触发(间隔 ${minutes} 分钟,账号 ${this.accounts.length} 个)`);
this.syncAll(false);
}
}, 15000);
+195
View File
@@ -2,6 +2,8 @@
// 设置页:系统日历模式(仅显示/备份到 CalDAV)+ 混合显示开关 + 自动同步间隔 + 后台同步
import { router } from '@kit.ArkUI';
import { common } from '@kit.AbilityKit';
import { pasteboard } from '@kit.BasicServicesKit';
import { notificationManager } from '@kit.NotificationKit';
import { AppSettings } from '../common/AppSettings';
import { BackgroundSyncService } from '../common/BackgroundSyncService';
import { AccountStore, DavAccount } from '../common/AccountStore';
@@ -29,6 +31,10 @@ struct SettingsPage {
@State allBooks: BackupTarget[] = []; // 全部 DAV 日历本(只读标记管理用)
@State manualKeys: string[] = []; // 手动标记只读的 calKey
@State mutedKeys: string[] = []; // 提醒静音的 calKey
@State showLogSheet: boolean = false; // 同步日志查看弹层
@State logText: string = '';
@State notifyEnabled: boolean = true; // 通知权限状态(提醒依赖)
@State lastTestResult: string = '';
private context?: common.Context;
aboutToAppear(): void {
@@ -56,6 +62,13 @@ struct SettingsPage {
AppSettings.getMutedReminderKeys(ctx).then((v: string[]): void => {
this.mutedKeys = v;
});
notificationManager.isNotificationEnabled()
.then((v: boolean): void => {
this.notifyEnabled = v;
})
.catch((): void => {
this.notifyEnabled = false;
});
this.loadBackupSettings();
this.loadAllBooks();
}
@@ -274,6 +287,65 @@ struct SettingsPage {
});
}
/** 打开同步日志查看弹层 */
private openLogSheet(): void {
if (this.context === undefined) {
return;
}
this.logText = LogUtil.readAll(this.context);
this.showLogSheet = true;
}
/** 复制全部日志到剪贴板(方便粘贴给我诊断) */
private copyLog(): void {
if (this.context === undefined) {
return;
}
try {
const data: pasteboard.PasteData = pasteboard.createData(
pasteboard.MIMETYPE_TEXT_PLAIN, LogUtil.readAll(this.context));
pasteboard.getSystemPasteboard().setData(data)
.then((): void => {
this.getUIContext().getPromptAction().showToast({ message: '日志已复制到剪贴板' });
})
.catch((): void => {
this.getUIContext().getPromptAction().showToast({ message: '复制失败' });
});
} catch (err) {
this.getUIContext().getPromptAction().showToast({ message: '复制失败' });
}
}
private clearLog(): void {
if (this.context === undefined) {
return;
}
LogUtil.clear(this.context);
this.logText = '(日志已清空)';
this.getUIContext().getPromptAction().showToast({ message: '日志已清空' });
}
/** 发布 1 分钟后的测试提醒,验证提醒链路 */
private async testReminder(): Promise<void> {
if (this.context === undefined) {
return;
}
this.lastTestResult = await ReminderService.publishTestReminder(
this.context as common.UIAbilityContext);
}
/** 按当前数据立即重建提醒,显示发布条数 */
private async refreshNow(): Promise<void> {
if (this.context === undefined) {
return;
}
const n: number = await ReminderService.refreshReminders(
this.context as common.UIAbilityContext);
this.getUIContext().getPromptAction().showToast({
message: n > 0 ? `已发布 ${n} 个提醒` : '没有发布任何提醒(可能都过了提醒时间、被静音或通知未开启,详见日志)'
});
}
build() {
Column() {
// 顶部
@@ -581,6 +653,85 @@ struct SettingsPage {
.borderRadius(12)
.backgroundColor($r('app.color.card_bg'))
.border({ width: 1, color: $r('app.color.shadow_color') })
// 提醒诊断:通知权限状态 + 测试提醒 + 立即刷新
Column({ space: 8 }) {
Row({ space: 10 }) {
Column({ space: 2 }) {
Row({ space: 6 }) {
Text('提醒诊断')
.fontSize(15)
.fontWeight(FontWeight.Medium)
.fontColor($r('app.color.text_primary'))
Text(this.notifyEnabled ? '通知已开启' : '通知未开启!')
.fontSize(11)
.fontColor(this.notifyEnabled ? $r('app.color.success') : $r('app.color.error'))
.padding({ left: 8, right: 8, top: 3, bottom: 3 })
.borderRadius(10)
.backgroundColor(this.notifyEnabled ? $r('app.color.success_bg') : $r('app.color.error_bg'))
}
Text(this.notifyEnabled
? '点"测试提醒"验证链路:1 分钟后应收到通知'
: '系统设置 → 通知管理 → 找到本应用 → 允许通知,日程提醒才能弹出')
.fontSize(12)
.fontColor($r('app.color.text_secondary'))
}
.alignItems(HorizontalAlign.Start)
.layoutWeight(1)
}
.width('100%')
Row({ space: 10 }) {
Button('测试提醒')
.fontSize(13)
.backgroundColor($r('app.color.brand'))
.onClick(() => {
this.testReminder();
})
Button('立即刷新提醒')
.fontSize(13)
.backgroundColor($r('app.color.text_secondary'))
.onClick(() => {
this.refreshNow();
})
}
if (this.lastTestResult !== '') {
Text(this.lastTestResult)
.fontSize(12)
.fontColor($r('app.color.text_secondary'))
.width('100%')
}
}
.alignItems(HorizontalAlign.Start)
.width('100%')
.padding(14)
.borderRadius(12)
.backgroundColor($r('app.color.card_bg'))
.border({ width: 1, color: $r('app.color.shadow_color') })
// 同步日志:查看/复制/清空(真机测试诊断用)
Row({ space: 10 }) {
Column({ space: 2 }) {
Text('同步日志')
.fontSize(15)
.fontWeight(FontWeight.Medium)
.fontColor($r('app.color.text_primary'))
Text('记录每次同步/推送/提醒的详细过程,测试出问题时复制日志用于分析')
.fontSize(12)
.fontColor($r('app.color.text_secondary'))
}
.alignItems(HorizontalAlign.Start)
.layoutWeight(1)
Button('查看')
.fontSize(13)
.backgroundColor($r('app.color.brand'))
.onClick(() => {
this.openLogSheet();
})
}
.width('100%')
.padding(14)
.borderRadius(12)
.backgroundColor($r('app.color.card_bg'))
.border({ width: 1, color: $r('app.color.shadow_color') })
}
.width('100%')
.padding({ left: 20, right: 20, top: 8, bottom: 20 })
@@ -588,9 +739,53 @@ struct SettingsPage {
.layoutWeight(1)
.align(Alignment.Top)
.scrollBar(BarState.Off)
.bindSheet($$this.showLogSheet, this.logSheetBuilder(), {
height: 560,
dragBar: true,
title: { title: '同步日志' }
})
}
.width('100%')
.height('100%')
.backgroundColor($r('app.color.page_bg'))
}
@Builder
logSheetBuilder() {
Column({ space: 10 }) {
Row({ space: 10 }) {
Button('复制全部')
.fontSize(13)
.backgroundColor($r('app.color.brand'))
.onClick(() => {
this.copyLog();
})
Button('清空')
.fontSize(13)
.backgroundColor($r('app.color.error'))
.onClick(() => {
this.clearLog();
})
Button('刷新')
.fontSize(13)
.backgroundColor($r('app.color.text_secondary'))
.onClick(() => {
this.openLogSheet();
})
}
Scroll() {
Text(this.logText === '' ? '(日志为空)' : this.logText)
.fontSize(11)
.fontColor($r('app.color.text_primary'))
.width('100%')
}
.layoutWeight(1)
.align(Alignment.Top)
.scrollBar(BarState.On)
}
.width('100%')
.height('100%')
.padding(16)
.backgroundColor($r('app.color.page_bg'))
}
}