laoyang/SyncCalendar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.增加了重力感应，也就是横屏响应式布局。

Browse Source 
2.修改了沉浸式布局。
3.修改了添加日程和编辑日程页面，增加了重复、提醒等功能。
4.修改了权限问题，如果日历本是只读，则有删除线做标识。同时，对于只读的日程，点击后将不再进入编辑页面，而是展示详情。
5.系统日历的处理。给用户两个选择，第一个选择就是只显示系统日历。第二种选择，用户可以选择一个caldav账户中的某一个日历本，把系统日历中的日程，包括日历日程和应用创建的日程，都读取出来，然后加入到这个日历本下，最后同步到caldav的服务器上，这样的好处是，手机丢失了，或者换了手机品牌型号，手机上的日程仍然在自己的caldav服务器上有一个备份。当然，系统日历中的caldav日历，就不会再读取了。
This commit is contained in:
laoyang
2026-09-13 20:25:18 +08:00
parent 61bd6fc75f
commit 04fdf3d386
14 changed files with 1211 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files
entry/src/main/ets/common/AccountStore.ets
+8 -1
View File
@@ -26,6 +26,8 @@ export class DavAccount {
calendarNames: string[] = [];
/** 服务器端定义的日历本颜色（calendar-color），与 calendarHrefs 一一对应，空串表示未定义 */
calendarColors: string[] = [];
/** 各日历本写权限（'1'=可写 '0'=只读），与 calendarHrefs 一一对应；空数组表示未知（按可写处理） */
calendarWritable: string[] = [];
itemCount: number = 0;
lastSyncTime: string = '';
}
@@ -37,6 +39,7 @@ export class CalSource {
color: string = '#007DFF';
source: string = 'dav'; // 'dav' | 'system' | 'local'
visible: boolean = true;
writable: boolean = true; // 只读日历本中的日程只能查看详情，不能编辑
}
/** 与 UI 无关的调色板 */
@@ -81,7 +84,8 @@ export class AccountStore {
acc.calendarHrefs.join(';'),
acc.calendarNames.join(';'),
acc.calendarColors.join(';'),
safe(acc.id)
safe(acc.id),
acc.calendarWritable.join(';')
];
return parts.join('|');
}
@@ -109,6 +113,9 @@ export class AccountStore {
if (parts.length >= 11) {
acc.id = parts[10];
}
if (parts.length >= 12) {
acc.calendarWritable = parts[11] === '' ? [] : parts[11].split(';');
}
return acc;
}
entry/src/main/ets/common/AppSettings.ets
+77
View File
@@ -9,6 +9,83 @@ export class AppSettings {
private static readonly KEY_SHOW_SYSTEM: string = 'show_system_calendar';
private static readonly KEY_SYNC_INTERVAL: string = 'sync_interval_minutes';
private static readonly KEY_BACKGROUND_SYNC: string = 'background_sync';
private static readonly KEY_SYS_MODE: string = 'sys_cal_mode'; // 'display' | 'backup'
private static readonly KEY_BACKUP_KEY: string = 'sys_backup_cal_key'; // 备份目标 DAV 日历本
private static readonly KEY_MANUAL_READONLY: string = 'manual_readonly_keys'; // 手动标记只读的 calKey
/**
* 手动标记为只读的日历本 calKey 列表。
* 部分服务器（如群晖某些共享方式）不在 CalDAV 层拒绝写入，自动探测无法区分，
* 由用户手动标记，标记后其中日程只显示详情、不出现在新建日程选择中。
*/
static async getManualReadonlyKeys(context: common.Context): Promise<string[]> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
const raw: string = await store.get(AppSettings.KEY_MANUAL_READONLY, '') as string;
return raw === '' ? [] : raw.split(';');
} catch (err) {
return [];
}
}
static async setManualReadonlyKeys(context: common.Context, keys: string[]): Promise<void> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
await store.put(AppSettings.KEY_MANUAL_READONLY, keys.join(';'));
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 {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
return await store.get(AppSettings.KEY_SYS_MODE, 'display') as string;
} catch (err) {
return 'display';
}
}
static async setSysCalMode(context: common.Context, mode: string): Promise<void> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
await store.put(AppSettings.KEY_SYS_MODE, mode);
await store.flush();
} catch (err) {
const e = err as BusinessError;
console.error(`保存系统日历模式失败: ${e.message}`);
}
}
/** 备份目标日历本 calKey（accId_序号），空 = 未选择 */
static async getBackupCalKey(context: common.Context): Promise<string> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
return await store.get(AppSettings.KEY_BACKUP_KEY, '') as string;
} catch (err) {
return '';
}
}
static async setBackupCalKey(context: common.Context, calKey: string): Promise<void> {
try {
const store: preferences.Preferences =
await preferences.getPreferences(context, AppSettings.STORE);
await store.put(AppSettings.KEY_BACKUP_KEY, calKey);
await store.flush();
} catch (err) {
const e = err as BusinessError;
console.error(`保存备份目标失败: ${e.message}`);
}
}
/** 是否开启后台持续同步（长时任务，默认关） */
static async getBackgroundSync(context: common.Context): Promise<boolean> {
entry/src/main/ets/common/CalendarDataService.ets
+11
View File
@@ -25,6 +25,7 @@ export class DisplayEvent {
color: string = '#007DFF';
completed: boolean = false; // 仅待办使用
recurring: boolean = false; // 是否为重复日程展开出的发生
writable: boolean = true; // 所属日历本是否可写（只读时点击显示详情而非编辑）
}
export class CalendarDataService {
@@ -53,6 +54,7 @@ export class CalendarDataService {
/** 收集全部日历来源：DAV 日历本 + 本机 + 系统日历账户 */
static async loadSources(context: common.Context): Promise<CalSource[]> {
const sources: CalSource[] = [];
const manualKeys: string[] = await AppSettings.getManualReadonlyKeys(context);
try {
const accounts: DavAccount[] = await AccountStore.loadAll(context);
for (const acc of accounts) {
@@ -69,6 +71,10 @@ export class CalendarDataService {
s.color = color !== '' ? color : BookPalette.colorFor(i);
s.source = 'dav';
s.visible = true;
// 写权限：服务器探测结果 + 手动标记（部分服务器不在 CalDAV 层拒绝写入）
const detected: boolean = acc.calendarWritable.length > i
? acc.calendarWritable[i] !== '0' : true;
s.writable = detected && !manualKeys.includes(s.calKey);
sources.push(s);
}
}
@@ -142,6 +148,10 @@ export class CalendarDataService {
const found = sources.find((s: CalSource): boolean => s.calKey === key);
return found !== undefined ? found.name : '';
};
const writableOf = (key: string): boolean => {
const found = sources.find((s: CalSource): boolean => s.calKey === key);
return found !== undefined ? found.writable : true;
};
// 1) 本地库（DAV + 本机）；重复日程(RRULE)按规则展开为窗口内的多次发生
try {
@@ -202,6 +212,7 @@ export class CalendarDataService {
d.calName = baseName;
d.color = baseColor;
d.recurring = e.rrule !== '';
d.writable = writableOf(e.calKey);
result.push(d);
occTotal++;
}
entry/src/main/ets/common/DavClient.ets
+66 -1
View File
@@ -12,10 +12,12 @@ export class RemoteItem {
ics: string = ''; // VCALENDAR 文本
}
/** PROPFIND 返回的集合颜色 */
/** PROPFIND 返回的集合颜色与写权限 */
export class DavColorEntry {
href: string = ''; // 集合路径（服务器返回的是路径，不带域名）
color: string = ''; // 规范化后的 #RRGGBB，可能为空
writable: boolean = true; // current-user-privilege 是否含 write 权限（默认可写）
privilegeKnown: boolean = false; // 服务器是否返回了 current-user-privilege-set（未返回时需要写探测）
}
export class DavClient {
@@ -28,6 +30,7 @@ export class DavClient {
'<d:propfind xmlns:d="DAV:" xmlns:cs="http://calendarserver.org/ns/" ' +
'xmlns:ical="http://apple.com/ns/ical/"><d:prop>' +
'<d:resourcetype/><cs:getcolor/><ical:calendar-color/>' +
'<d:current-user-privilege-set/>' +
'</d:prop></d:propfind>';
const httpRequest = http.createHttp();
try {
@@ -71,6 +74,13 @@ export class DavClient {
color = DavClient.normalizeHex(DavClient.extractTag(block, 'calendar-color'));
}
entry.color = color;
// 写权限：current-user-privilege-set 存在且不含任何 write 权限 → 只读
const privSet: string = DavClient.extractTag(block, 'current-user-privilege-set');
if (privSet !== '') {
entry.privilegeKnown = true;
entry.writable = /write/i.test(privSet);
LogUtil.write(`PROPFIND ${href} 权限声明：${privSet.replace(/\s+/g, '').substring(0, 150)}`);
}
result.push(entry);
}
if (result.length > 0 && result.every((e: DavColorEntry): boolean => e.color === '')) {
@@ -100,6 +110,61 @@ export class DavClient {
return 'Basic ' + buffer.from(`${username}:${password}`).toString('base64');
}
/**
* 写权限探测：向日历本 PUT 一个探测资源——
* 2xx → 可写（随后删除探测资源）；403/401 等 → 只读；网络异常 → 乐观按可写。
* 用于服务器不返回 current-user-privilege-set 的情况（如部分 Synology 配置）。
*/
static async probeWritable(href: string, auth: string): Promise<boolean> {
const url: string = href.endsWith('/')
? `${href}synccalendar-probe.ics` : `${href}/synccalendar-probe.ics`;
const ics: string = 'BEGIN:VCALENDAR\r\n' +
'VERSION:2.0\r\n' +
'PRODID:-//SyncCalendar//Probe//CN\r\n' +
'BEGIN:VEVENT\r\n' +
'UID:syncprobe\r\n' +
'DTSTAMP:20000101T000000Z\r\n' +
'DTSTART:20000101T000000Z\r\n' +
'DTEND:20000101T010000Z\r\n' +
'SUMMARY:probe\r\n' +
'END:VEVENT\r\n' +
'END:VCALENDAR\r\n';
const httpRequest = http.createHttp();
try {
const resp: http.HttpResponse = await httpRequest.request(url, {
method: http.RequestMethod.PUT,
header: {
'Authorization': auth,
'Content-Type': 'text/calendar; charset=utf-8',
'User-Agent': 'SyncCalendar/1.0'
},
extraData: ics,
connectTimeout: 10000,
readTimeout: 15000
});
LogUtil.write(`HTTP PUT(探测) ${url} → ${resp.responseCode}`);
if (resp.responseCode >= 200 && resp.responseCode < 300) {
// 写入成功：删除探测资源，避免污染日历本
try {
await DavClient.deleteRemote(url, auth);
} catch (err) {
// 删除失败不影响权限判定
}
return true;
}
if (resp.responseCode === 412 || resp.responseCode === 405 || resp.responseCode === 409) {
// 资源已存在/方法冲突等：说明有写权限
return true;
}
return false; // 403/401 等 → 只读
} catch (err) {
// 网络异常无法判定：乐观按可写，避免误标只读
return true;
} finally {
httpRequest.destroy();
}
}
/** REPORT calendar-query：全量拉取某日历本内所有 VEVENT（不加时间范围，保证数据完整） */
static async reportCalendar(href: string, auth: string): Promise<RemoteItem[]> {
return DavClient.reportComponents(href, auth, 'VEVENT', '');
entry/src/main/ets/common/EventDb.ets
+11
View File
@@ -409,6 +409,17 @@ export class EventDb {
return `新增${added} 更新${updated} 删除${removed} 不变${unchanged}`;
}
/** 按 UID 判断事件是否已存在（系统日历备份导入的幂等判重） */
static async uidExists(context: common.Context, uid: string): Promise<boolean> {
const store = await EventDb.getDb(context);
const predicates = new relationalStore.RdbPredicates('events');
predicates.equalTo('uid', uid);
const rs = await store.query(predicates);
const exists: boolean = rs.rowCount > 0;
rs.close();
return exists;
}
/** 删除某账号全部本地事件（删除账号时调用） */
static async deleteAccountEvents(context: common.Context, accId: string): Promise<void> {
const store = await EventDb.getDb(context);
entry/src/main/ets/common/IcsUtil.ets
+19
View File
@@ -240,13 +240,32 @@ export class IcsUtil {
`DTSTAMP:${now}\r\n` +
`${dtstart}\r\n` +
`${dtend}\r\n` +
(e.rrule !== '' ? `RRULE:${e.rrule}\r\n` : '') +
`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) : '') +
'END:VEVENT\r\n' +
'END:VCALENDAR\r\n';
}
/** 由提前分钟数生成 VALARM（TRIGGER 负时长 = 提前触发） */
private static valarm(minutes: number): string {
let trigger: string;
if (minutes >= 1440 && minutes % 1440 === 0) {
trigger = `-P${minutes / 1440}D`;
} else if (minutes >= 60 && minutes % 60 === 0) {
trigger = `-PT${minutes / 60}H`;
} else {
trigger = `-PT${minutes}M`;
}
return 'BEGIN:VALARM\r\n' +
`TRIGGER:${trigger}\r\n` +
'ACTION:DISPLAY\r\n' +
'DESCRIPTION:提醒\r\n' +
'END:VALARM\r\n';
}
static escape(s: string): string {
return s.replace(/\\/g, '\\\\').replace(/;/g, '\\;').replace(/,/g, '\\,').replace(/\n/g, '\\n');
}
entry/src/main/ets/common/SyncEngine.ets
+51 -24
View File
@@ -70,6 +70,9 @@ export class SyncEngine {
}
// 一个资源可能包含主事件 + 单次覆盖实例（RECURRENCE-ID），全部入库
for (const r of parsed) {
if (r.uid === 'syncprobe') {
continue; // 写权限探测资源（万一删除失败），不入库展示
}
if (r.uid === '') {
r.uid = SyncEngine.uidFromHref(it.href);
}
@@ -113,31 +116,44 @@ export class SyncEngine {
* 失败静默（颜色不影响数据正确性）
*/
static async refreshCalendarColors(acc: DavAccount, auth: string): Promise<void> {
let entries: DavColorEntry[] = [];
try {
const entries: DavColorEntry[] = await DavClient.propfindColors(acc.serverUrl, auth);
if (entries.length === 0) {
return;
}
for (let i = 0; i < acc.calendarHrefs.length; i++) {
const target: string = acc.calendarHrefs[i];
const originMatch = /https?:\/\/[^/]+/i.exec(target);
let path: string = originMatch !== null ? target.substring(originMatch[0].length) : target;
if (path === '') {
path = '/';
}
const norm = (s: string): string => s.endsWith('/') ? s : s + '/';
const found = entries.find((e: DavColorEntry): boolean =>
norm(e.href) === norm(path));
if (found !== undefined && found.color !== '') {
while (acc.calendarColors.length <= i) {
acc.calendarColors.push('');
}
acc.calendarColors[i] = found.color;
}
}
entries = await DavClient.propfindColors(acc.serverUrl, auth);
} catch (err) {
const e = err as BusinessError;
console.info(`刷新日历本颜色失败(忽略): ${e.message}`);
LogUtil.write(`PROPFIND 颜色/权限失败(继续探测写权限): ${e.message}`);
}
for (let i = 0; i < acc.calendarHrefs.length; i++) {
const target: string = acc.calendarHrefs[i];
const originMatch = /https?:\/\/[^/]+/i.exec(target);
let path: string = originMatch !== null ? target.substring(originMatch[0].length) : target;
if (path === '') {
path = '/';
}
const norm = (s: string): string => s.endsWith('/') ? s : s + '/';
const found = entries.find((e: DavColorEntry): boolean =>
norm(e.href) === norm(path));
if (found !== undefined && found.color !== '') {
while (acc.calendarColors.length <= i) {
acc.calendarColors.push('');
}
acc.calendarColors[i] = found.color;
}
// 回写各日历本写权限（'1'=可写 '0'=只读）
while (acc.calendarWritable.length <= i) {
acc.calendarWritable.push('1');
}
const calName: string = i < acc.calendarNames.length ? acc.calendarNames[i] : `日历本${i}`;
if (found !== undefined && found.privilegeKnown) {
// 服务器声明了权限：直接采用
acc.calendarWritable[i] = found.writable ? '1' : '0';
LogUtil.write(`日历本[${i}]「${calName}」写权限(privilege)：${found.writable ? '可写' : '只读'}`);
} else {
// 服务器未声明权限（如部分 Synology 配置）或 PROPFIND 未匹配到该本：真实写探测
const w: boolean = await DavClient.probeWritable(target, auth);
acc.calendarWritable[i] = w ? '1' : '0';
LogUtil.write(`日历本[${i}]「${calName}」写权限(探测)：${w ? '可写' : '只读'}`);
}
}
}
@@ -159,17 +175,28 @@ export class SyncEngine {
const mine: LocalEvent[] = dirty.filter((e: LocalEvent): boolean => acc.calendarHrefs.includes(e.href));
LogUtil.write(`推送本地修改：全部待推送 ${dirty.length} 条，属于账号「${acc.name}」的 ${mine.length} 条`);
for (const e of mine) {
// 只读日历本：推送必然 403，跳过并保留 dirty（权限恢复后可再推）
const bookIdx: number = acc.calendarHrefs.indexOf(e.href);
if (bookIdx >= 0 && acc.calendarWritable.length > bookIdx
&& acc.calendarWritable[bookIdx] === '0') {
LogUtil.write(`推送跳过只读日历本事件「${e.title}」(uid=${e.uid})`);
continue;
}
if (e.kind === 'todo') {
// 待办只读：本地不会有 dirty 待办，兜底清除
await EventDb.clearDirty(context, e.id, e.etag);
continue;
}
if (e.recurring) {
// 重复日程实例推送会破坏服务器整个序列，暂不支持
if (e.recurring && e.rrule === '') {
// 重复日程的"单次覆盖实例"（RECURRENCE-ID）推送会破坏服务器整个序列，暂不支持
await EventDb.clearDirty(context, e.id, e.etag);
LogUtil.write(`推送跳过重复日程实例「${e.title}」(uid=${e.uid})`);
continue;
}
if (e.recurring) {
// 重复主事件（含 RRULE，含本机新建的重复日程）：整条 PUT 覆盖推送
LogUtil.write(`推送重复主事件「${e.title}」(uid=${e.uid})`);
}
const url: string = e.href.endsWith('/') ? e.href + e.remotePath : `${e.href}/${e.remotePath}`;
if (e.deleted) {
await DavClient.deleteRemote(url, auth);
entry/src/main/ets/common/SystemCalendarImport.ets
+121
View File
@@ -0,0 +1,121 @@
// entry/src/main/ets/common/SystemCalendarImport.ets
// 系统日历备份：把手机"本地"系统日历（非 CalDAV 同步日历）的全部日程导入
// 用户选定的 CalDAV 日历本（置 dirty 待推送），随后随同步上传服务器。
// 价值：手机丢失/换机后，系统日历日程在用户自己的 CalDAV 服务器上仍有备份。
import { common } from '@kit.AbilityKit';
import { calendarManager } from '@kit.CalendarKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { AccountStore, DavAccount } from './AccountStore';
import { EventDb, LocalEvent } from './EventDb';
import { AppSettings } from './AppSettings';
import { LogUtil } from './LogUtil';
export class SystemCalendarImport {
/**
* 备份模式下的导入入口（display 模式直接返回 0）。
* 幂等：uid = syscal-<系统日历id>-<事件id>，已存在则跳过，因此每次同步都可安全执行。
* 只读取 calendarType = LOCAL 的系统日历（手机本地日历/应用创建的日程），
* 系统 CalDAV 同步产生的账户日历一律跳过，避免死循环回灌。
*/
static async importIfNeeded(context: common.Context): Promise<number> {
try {
const mode: string = await AppSettings.getSysCalMode(context);
if (mode !== 'backup') {
return 0;
}
const calKey: string = await AppSettings.getBackupCalKey(context);
if (calKey === '') {
LogUtil.write('系统日历备份：未选择目标日历本，跳过导入');
return 0;
}
// 定位目标 CalDAV 日历本
const accounts: DavAccount[] = await AccountStore.loadAll(context);
let targetHref: string = '';
for (const acc of accounts) {
for (let i = 0; i < acc.calendarHrefs.length; i++) {
if (`${acc.id}_${i}` === calKey) {
targetHref = acc.calendarHrefs[i];
}
}
}
if (targetHref === '') {
LogUtil.write(`系统日历备份：目标日历本 ${calKey} 不存在（账号可能已删除），跳过导入`);
return 0;
}
const uiContext = context as common.UIAbilityContext;
const mgr: calendarManager.CalendarManager = calendarManager.getCalendarManager(uiContext);
const calendars: calendarManager.Calendar[] = await mgr.getAllCalendars();
let imported: number = 0;
let skippedCal: number = 0;
for (const cal of calendars) {
try {
// 只处理"本地"类型系统日历；CalDAV/订阅等账户日历的数据源本来就在服务器上，跳过防回灌
const account: calendarManager.CalendarAccount = cal.getAccount();
if (account.type !== calendarManager.CalendarType.LOCAL) {
skippedCal++;
continue;
}
const events: calendarManager.Event[] = await cal.getEvents();
for (const ev of events) {
if (ev.id === undefined) {
continue;
}
const uid: string = `syscal-${account.name}-${ev.id}`;
if (await EventDb.uidExists(context, uid)) {
continue;
}
const e = new LocalEvent();
e.uid = uid;
e.calKey = calKey;
e.href = targetHref;
e.remotePath = encodeURIComponent(uid) + '.ics';
e.title = ev.title !== undefined ? ev.title : '';
e.description = ev.description !== undefined ? ev.description : '';
e.location = ev.location !== undefined && ev.location.location !== undefined
? ev.location.location : '';
e.startTime = ev.startTime;
e.endTime = ev.endTime;
e.isAllDay = ev.isAllDay === true;
e.kind = 'event';
e.rrule = SystemCalendarImport.rruleOf(ev);
e.recurring = e.rrule !== '';
await EventDb.insertLocal(context, e); // insertLocal 置 dirty，随同步推送
imported++;
}
} catch (err) {
// 单个日历读取失败不影响其余
}
}
if (imported > 0 || skippedCal > 0) {
LogUtil.write(`系统日历备份：新增 ${imported} 条 → ${calKey}（跳过账户日历 ${skippedCal} 个）`);
}
return imported;
} catch (err) {
const e = err as BusinessError;
LogUtil.write(`系统日历备份导入失败(忽略): ${e.message}`);
return 0;
}
}
/** 系统日程的 recurrenceRule → 尽力转换的 RRULE 字符串（仅 FREQ/INTERVAL，复杂规则服务器端可再完善） */
private static rruleOf(ev: calendarManager.Event): string {
try {
const rr = ev.recurrenceRule;
if (rr === undefined) {
return '';
}
const freqMap: string[] = ['YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY'];
const fi: number = rr.recurrenceFrequency as number;
if (Number.isNaN(fi) || fi < 0 || fi >= freqMap.length) {
return '';
}
let rrule: string = `FREQ=${freqMap[fi]}`;
if (rr.interval !== undefined && rr.interval > 1) {
rrule += `;INTERVAL=${rr.interval}`;
}
return rrule;
} catch (err) {
return '';
}
}
}