From 8ef51d3418c1e97e123afe91c9a68c36f37ea365 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:28:42 +0800 Subject: [PATCH 01/12] Update MetaData.java --- src/gtask/data/MetaData.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/gtask/data/MetaData.java b/src/gtask/data/MetaData.java index 568372c..679b471 100644 --- a/src/gtask/data/MetaData.java +++ b/src/gtask/data/MetaData.java @@ -38,7 +38,6 @@ public class MetaData extends Task { } /* * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存 - * Made By CuiCan */ @Override public boolean isWorthSaving() { @@ -67,7 +66,6 @@ public class MetaData extends Task { } /* * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常 - * Made By CuiCan */ @Override public void setContentByLocalJSON(JSONObject js) { @@ -79,26 +77,22 @@ public class MetaData extends Task { } /* * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常 - * Made By CuiCan */ @Override public JSONObject getLocalJSONFromContent() { throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); /* * 传递非法参数异常 - * Made By Cui Can */ } /* * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常 - * Made By CuiCan */ @Override public int getSyncAction(Cursor c) { throw new IllegalAccessError("MetaData:getSyncAction should not be called"); /* * 传递非法参数异常 - * Made By Cui Can */ } From a40f4948e6b8b06d7159cbc7abd29b976289c797 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:30:57 +0800 Subject: [PATCH 02/12] Update SqlData.java --- src/gtask/data/SqlData.java | 23 +---------------------- 1 file changed, 1 insertion(+), 22 deletions(-) diff --git a/src/gtask/data/SqlData.java b/src/gtask/data/SqlData.java index 1a1a492..b03b87f 100644 --- a/src/gtask/data/SqlData.java +++ b/src/gtask/data/SqlData.java @@ -6,18 +6,11 @@ */ package net.micode.notes.gtask.data; -/* - * 功能描述： - * 实现过程： - * 参数注解： - * Made By CuiCan - */ - + public class SqlData { /* * 功能描述：得到类的简写名称存入字符串TAG中 * 实现过程：调用getSimpleName ()函数 - * Made By CuiCan */ private static final String TAG = SqlData.class.getSimpleName(); @@ -67,8 +60,6 @@ public class SqlData { * 功能描述：构造函数，用于初始化数据 * 参数注解：mContentResolver用于获取ContentProvider提供的数据 * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） - * 参数注解： - * Made By CuiCan */ public SqlData(Context context) { mContentResolver = context.getContentResolver(); @@ -86,8 +77,6 @@ public class SqlData { * 功能描述：构造函数，初始化数据 * 参数注解：mContentResolver用于获取ContentProvider提供的数据 * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） - * 参数注解： - * Made By CuiCan */ public SqlData(Context context, Cursor c) { mContentResolver = context.getContentResolver(); @@ -99,7 +88,6 @@ public class SqlData { /* * 功能描述：从光标处加载数据 * 从当前的光标处将五列的数据加载到该类的对象 - * Made By CuiCan */ private void loadFromCursor(Cursor c) { mDataId = c.getLong(DATA_ID_COLUMN); @@ -112,8 +100,6 @@ public class SqlData { /* * 功能描述：设置用于共享的数据，并提供异常抛出与处理机制 - * 参数注解： - * Made By CuiCan */ public void setContent(JSONObject js) throws JSONException { //如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID @@ -152,8 +138,6 @@ public class SqlData { /* * 功能描述：获取共享的数据内容，并提供异常抛出与处理机制 - * 参数注解： - * Made By CuiCan */ public JSONObject getContent() throws JSONException { if (mIsCreate) { @@ -172,8 +156,6 @@ public class SqlData { /* * 功能描述：commit函数用于把当前造作所做的修改保存到数据库 - * 参数注解： - * Made By CuiCan */ public void commit(long noteId, boolean validateVersion, long version) { @@ -216,9 +198,6 @@ public class SqlData { /* * 功能描述：获取当前id - * 实现过程： - * 参数注解： - * Made By CuiCan */ public long getId() { return mDataId; From 0a6bc883b28604893e362cb35d191b84c7369bf1 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:44:50 +0800 Subject: [PATCH 03/12] Update SqlNote.java --- src/gtask/data/SqlNote.java | 507 ++++++++++++++++++------------------ 1 file changed, 257 insertions(+), 250 deletions(-) diff --git a/src/gtask/data/SqlNote.java b/src/gtask/data/SqlNote.java index de1685a..7eaa830 100644 --- a/src/gtask/data/SqlNote.java +++ b/src/gtask/data/SqlNote.java @@ -5,18 +5,11 @@ */ package net.micode.notes.gtask.data; -/* - * 功能描述： - * 实现过程： - * 参数注解： - * Made By CuiCan - */ - + public class SqlNote { /* * 功能描述：得到类的简写名称存入字符串TAG中 * 实现过程：调用getSimpleName ()函数 - * Made By CuiCan */ private static final String TAG = SqlNote.class.getSimpleName(); @@ -106,8 +99,6 @@ public class SqlNote { /* * 功能描述：构造函数 * 参数注解： mIsCreate用于标示构造方式 - * 参数注解： - * Made By CuiCan */ //构造函数只有context，对所有的变量进行初始化 public SqlNote(Context context) { @@ -135,8 +126,6 @@ public class SqlNote { /* * 功能描述：构造函数 * 参数注解： mIsCreate用于标示构造方式 - * 参数注解： - * Made By CuiCan */ //构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化 public SqlNote(Context context, Cursor c) { @@ -155,8 +144,6 @@ public class SqlNote { /* * 功能描述：构造函数 * 参数注解： mIsCreate用于标示构造方式 - * 参数注解： - * Made By CuiCan */ public SqlNote(Context context, long id) { mContext = context; @@ -172,7 +159,6 @@ public class SqlNote { /* * 功能描述：通过id从光标处加载数据 - * Made By CuiCan */ private void loadFromCursor(long id) { Cursor c = null; @@ -196,7 +182,6 @@ public class SqlNote { /* * 功能描述：通过游标从光标处加载数据 - * Made By CuiCan */ private void loadFromCursor(Cursor c) { //直接从一条记录中的获得以下变量的初始值 @@ -216,188 +201,216 @@ public class SqlNote { /* * 功能描述：通过content机制获取共享数据并加载到数据库当前游标处 - * 参数注解： - * Made By CuiCan */ private void loadDataContent() { - Cursor c = null; - mDataList.clear(); + Cursor c = null; // 初始化一个游标对象 c + + mDataList.clear(); // 清空 mDataList，这可能是一个用于存储从内容提供者检索到的数据的列表 + try { - c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, - "(note_id=?)", new String[] { - String.valueOf(mId) - }, null); + // 使用内容解析器（mContentResolver）查询 Notes.CONTENT_DATA_URI，根据指定的 note_id 检索数据 + c = mContentResolver.query( + Notes.CONTENT_DATA_URI, // 数据的 URI + SqlData.PROJECTION_DATA, // 要检索的列投影 + "(note_id=?)", // 选择条件，基于 note_id + new String[] { String.valueOf(mId) }, // 选择条件中的参数，替换 note_id 的占位符 + null + ); + if (c != null) { if (c.getCount() == 0) { - Log.w(TAG, "it seems that the note has not data"); + Log.w(TAG, "似乎该笔记没有数据"); // 如果游标中没有数据，记录一个警告日志 return; } + + // 遍历游标中的数据，创建 SqlData 对象并添加到 mDataList 中 while (c.moveToNext()) { SqlData data = new SqlData(mContext, c); mDataList.add(data); } } else { - Log.w(TAG, "loadDataContent: cursor = null"); + Log.w(TAG, "loadDataContent: cursor = null"); // 如果游标为空，记录一个警告日志 } } finally { if (c != null) - c.close(); + c.close(); // 在最终块中确保关闭游标，释放资源 } } + + /* * 功能描述：设置通过content机制用于共享的数据信息 - * 参数注解： - * Made By CuiCan */ - public boolean setContent(JSONObject js) { - try { - JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); - if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { - Log.w(TAG, "cannot set system folder"); - } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { - // for folder we can only update the snnipet and type - String snippet = note.has(NoteColumns.SNIPPET) ? note - .getString(NoteColumns.SNIPPET) : ""; - if (mIsCreate || !mSnippet.equals(snippet)) { - mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); - } - mSnippet = snippet; - - int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) - : Notes.TYPE_NOTE; - if (mIsCreate || mType != type) { - mDiffNoteValues.put(NoteColumns.TYPE, type); - } - mType = type; - } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { - JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); - long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; - if (mIsCreate || mId != id) { - mDiffNoteValues.put(NoteColumns.ID, id); - } - mId = id; - - long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note - .getLong(NoteColumns.ALERTED_DATE) : 0; - if (mIsCreate || mAlertDate != alertDate) { - mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); - } - mAlertDate = alertDate; - - int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note - .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); - if (mIsCreate || mBgColorId != bgColorId) { - mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); - } - mBgColorId = bgColorId; - long createDate = note.has(NoteColumns.CREATED_DATE) ? note - .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); - if (mIsCreate || mCreatedDate != createDate) { - mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); - } - mCreatedDate = createDate; - - int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note - .getInt(NoteColumns.HAS_ATTACHMENT) : 0; - if (mIsCreate || mHasAttachment != hasAttachment) { - mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); - } - mHasAttachment = hasAttachment; - - long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note - .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); - if (mIsCreate || mModifiedDate != modifiedDate) { - mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); - } - mModifiedDate = modifiedDate; - - long parentId = note.has(NoteColumns.PARENT_ID) ? note - .getLong(NoteColumns.PARENT_ID) : 0; - if (mIsCreate || mParentId != parentId) { - mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); - } - mParentId = parentId; - - String snippet = note.has(NoteColumns.SNIPPET) ? note - .getString(NoteColumns.SNIPPET) : ""; - if (mIsCreate || !mSnippet.equals(snippet)) { - mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); - } - mSnippet = snippet; - - int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) - : Notes.TYPE_NOTE; - if (mIsCreate || mType != type) { - mDiffNoteValues.put(NoteColumns.TYPE, type); - } - mType = type; - - int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) - : AppWidgetManager.INVALID_APPWIDGET_ID; - if (mIsCreate || mWidgetId != widgetId) { - mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); - } - mWidgetId = widgetId; - - int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note - .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; - if (mIsCreate || mWidgetType != widgetType) { - mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); - } - mWidgetType = widgetType; - - long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note - .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; - if (mIsCreate || mOriginParent != originParent) { - mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); - } - mOriginParent = originParent; - - for (int i = 0; i < dataArray.length(); i++) { - JSONObject data = dataArray.getJSONObject(i); - SqlData sqlData = null; - if (data.has(DataColumns.ID)) { - long dataId = data.getLong(DataColumns.ID); - for (SqlData temp : mDataList) { - if (dataId == temp.getId()) { - sqlData = temp; - } - } - } - - if (sqlData == null) { - sqlData = new SqlData(mContext); - mDataList.add(sqlData); - } - - sqlData.setContent(data); - } - } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - return false; - } - return true; - } + public boolean setContent(JSONObject js) { + try { + // 从传入的 JSON 对象中获取笔记对象 + JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); + + // 检查笔记的类型，如果是系统文件夹则记录一个警告日志 + if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + Log.w(TAG, "无法设置系统文件夹"); + } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 对于文件夹，只能更新摘要和类型 + + // 获取摘要，如果没有则设置为空字符串 + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; + + // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中 + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + + // 获取类型，如果没有则默认为 Notes.TYPE_NOTE + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; + + // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中 + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { + // 处理笔记类型为 Note 的情况 + + // 从 JSON 中获取数据数组 + JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); + + // 获取笔记 ID，如果没有则设置为 INVALID_ID + long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; + + // 如果是创建操作或者 ID 发生变化，则将 ID 加入 mDiffNoteValues 中 + if (mIsCreate || mId != id) { + mDiffNoteValues.put(NoteColumns.ID, id); + } + mId = id; + + // 获取提醒日期，如果没有则设置为 0 + long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note.getLong(NoteColumns.ALERTED_DATE) : 0; + + // 如果是创建操作或者提醒日期发生变化，则将提醒日期加入 mDiffNoteValues 中 + if (mIsCreate || mAlertDate != alertDate) { + mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); + } + mAlertDate = alertDate; + + // 获取背景颜色 ID，如果没有则设置为默认值 + int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); + + // 如果是创建操作或者背景颜色 ID 发生变化，则将背景颜色 ID 加入 mDiffNoteValues 中 + if (mIsCreate || mBgColorId != bgColorId) { + mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); + } + mBgColorId = bgColorId; + + // 获取创建日期，如果没有则设置为当前时间 + long createDate = note.has(NoteColumns.CREATED_DATE) ? note.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); + + // 如果是创建操作或者创建日期发生变化，则将创建日期加入 mDiffNoteValues 中 + if (mIsCreate || mCreatedDate != createDate) { + mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); + } + mCreatedDate = createDate; + + // 获取是否有附件，如果没有则设置为 0 + int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note.getInt(NoteColumns.HAS_ATTACHMENT) : 0; + + // 如果是创建操作或者是否有附件发生变化，则将是否有附件加入 mDiffNoteValues 中 + if (mIsCreate || mHasAttachment != hasAttachment) { + mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); + } + mHasAttachment = hasAttachment; + + // 获取修改日期，如果没有则设置为当前时间 + long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); + + // 如果是创建操作或者修改日期发生变化，则将修改日期加入 mDiffNoteValues 中 + if (mIsCreate || mModifiedDate != modifiedDate) { + mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); + } + mModifiedDate = modifiedDate; + + // 获取父级 ID，如果没有则设置为 0 + long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0; + + // 如果是创建操作或者父级 ID 发生变化，则将父级 ID 加入 mDiffNoteValues 中 + if (mIsCreate || mParentId != parentId) { + mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); + } + mParentId = parentId; + + // 获取摘要，如果没有则设置为空字符串 + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; + + // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中 + if (mIsCreate || !mSnippet.equals(snippet)) { + mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); + } + mSnippet = snippet; + + // 获取类型，如果没有则默认为 Notes.TYPE_NOTE + int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; + + // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中 + if (mIsCreate || mType != type) { + mDiffNoteValues.put(NoteColumns.TYPE, type); + } + mType = type; + + // 获取小部件 ID，如果没有则设置为 AppWidgetManager.INVALID_APPWIDGET_ID + int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID; + + // 如果是创建操作或者小部件 ID 发生变化，则将小部件 ID 加入 mDiffNoteValues 中 + if (mIsCreate || mWidgetId != widgetId) { + mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); + } + mWidgetId = widgetId; + + // 获取小部件类型，如果没有则设置为 Notes.TYPE_WIDGET_INVALIDE + int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; + + // 如果是创建操作或者小部件类型发生变化，则将小部件类型加入 mDiffNoteValues 中 + if (mIsCreate || mWidgetType != widgetType) { + mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); + } + mWidgetType = widgetType; + + // 获取原始父级 ID，如果没有则设置为 0 + long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; + + // 如果是创建操作或者原始父级 ID 发生变化，则将原始父级 ID 加入 mDiffNoteValues 中 + if (mIsCreate || mOriginParent != originParent) { + mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); + } + mOriginParent = originParent; + } + } catch (JSONException e) { + // 如果发生异常，记录错误日志并返回 false + Log.e(TAG, e.toString()); + e.printStackTrace(); + return false; + } + return true; // 如果没有发生异常，返回 true 表示设置成功 + } + /* * 功能描述：获取content机制提供的数据并加载到note中 - * 参数注解： - * Made By CuiCan */ public JSONObject getContent() { try { JSONObject js = new JSONObject(); - + + // 如果是创建操作而没有在数据库中创建记录，记录一个错误日志并返回 null if (mIsCreate) { - Log.e(TAG, "it seems that we haven't created this in database yet"); + Log.e(TAG, "似乎我们还没有在数据库中创建这个记录"); return null; } - + JSONObject note = new JSONObject(); - if (mType == Notes.TYPE_NOTE) {//类型为note时 + + // 根据笔记的类型填充 note 对象的属性 + if (mType == Notes.TYPE_NOTE) { // 类型为 Note 时 note.put(NoteColumns.ID, mId); note.put(NoteColumns.ALERTED_DATE, mAlertDate); note.put(NoteColumns.BG_COLOR_ID, mBgColorId); @@ -411,7 +424,7 @@ public class SqlNote { note.put(NoteColumns.WIDGET_TYPE, mWidgetType); note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); js.put(GTaskStringUtils.META_HEAD_NOTE, note); - + JSONArray dataArray = new JSONArray(); for (SqlData sqlData : mDataList) { JSONObject data = sqlData.getContent(); @@ -420,13 +433,13 @@ public class SqlNote { } } js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); - } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//类型为文件夹或者 + } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { // 类型为文件夹或系统 note.put(NoteColumns.ID, mId); note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.SNIPPET, mSnippet); js.put(GTaskStringUtils.META_HEAD_NOTE, note); } - + return js; } catch (JSONException e) { Log.e(TAG, e.toString()); @@ -434,11 +447,10 @@ public class SqlNote { } return null; } + /* * 功能描述：给当前id设置父id - * 参数注解： - * Made By CuiCan */ public void setParentId(long id) { mParentId = id; @@ -447,8 +459,6 @@ public class SqlNote { /* * 功能描述：给当前id设置Gtaskid - * 参数注解： - * Made By CuiCan */ public void setGtaskId(String gid) { mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); @@ -456,8 +466,6 @@ public class SqlNote { /* * 功能描述：给当前id设置同步id - * 参数注解： - * Made By CuiCan */ public void setSyncId(long syncId) { mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); @@ -465,8 +473,6 @@ public class SqlNote { /* * 功能描述：初始化本地修改，即撤销所有当前修改 - * 参数注解： - * Made By CuiCan */ public void resetLocalModified() { mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); @@ -474,8 +480,6 @@ public class SqlNote { /* * 功能描述：获得当前id - * 参数注解： - * Made By CuiCan */ public long getId() { return mId; @@ -483,8 +487,6 @@ public class SqlNote { /* * 功能描述：获得当前id的父id - * 参数注解： - * Made By CuiCan */ public long getParentId() { return mParentId; @@ -492,8 +494,6 @@ public class SqlNote { /* * 功能描述：获取小片段即用于显示的部分便签内容 - * 参数注解： - * Made By CuiCan */ public String getSnippet() { return mSnippet; @@ -501,8 +501,6 @@ public class SqlNote { /* * 功能描述：判断是否为便签类型 - * 参数注解： - * Made By CuiCan */ public boolean isNoteType() { return mType == Notes.TYPE_NOTE; @@ -510,69 +508,78 @@ public class SqlNote { /* * 功能描述：commit函数用于把当前造作所做的修改保存到数据库 - * 参数注解： - * Made By CuiCan */ - public void commit(boolean validateVersion) { - if (mIsCreate) { - if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { - mDiffNoteValues.remove(NoteColumns.ID); - } - - Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); - try { - mId = Long.valueOf(uri.getPathSegments().get(1)); - } catch (NumberFormatException e) { - Log.e(TAG, "Get note id error :" + e.toString()); - throw new ActionFailureException("create note failed"); - } - if (mId == 0) { - throw new IllegalStateException("Create thread id failed"); - } - - if (mType == Notes.TYPE_NOTE) { - for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现 - sqlData.commit(mId, false, -1); - } - } - } else { - if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { - Log.e(TAG, "No such note"); - throw new IllegalStateException("Try to update note with invalid id"); - } - if (mDiffNoteValues.size() > 0) { - mVersion ++; - int result = 0; - if (!validateVersion) {//构造字符串 - result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" - + NoteColumns.ID + "=?)", new String[] { - String.valueOf(mId) - }); - } else { - result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" - + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", - new String[] { - String.valueOf(mId), String.valueOf(mVersion) - }); - } - if (result == 0) { - Log.w(TAG, "there is no update. maybe user updates note when syncing"); - } - } - - if (mType == Notes.TYPE_NOTE) { - for (SqlData sqlData : mDataList) { - sqlData.commit(mId, validateVersion, mVersion); - } - } - } - - // refresh local info - loadFromCursor(mId); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); - - mDiffNoteValues.clear(); - mIsCreate = false; - } -} \ No newline at end of file + public void commit(boolean validateVersion) { + if (mIsCreate) { + if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { + mDiffNoteValues.remove(NoteColumns.ID); + } + + // 将差异的笔记值插入数据库 + Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); + + try { + // 获取插入记录的ID并更新到当前对象的mId属性 + mId = Long.valueOf(uri.getPathSegments().get(1)); + } catch (NumberFormatException e) { + Log.e(TAG, "获取笔记ID出错：" + e.toString()); + throw new ActionFailureException("创建笔记失败"); + } + + if (mId == 0) { + throw new IllegalStateException("创建笔记ID失败"); + } + + // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表 + if (mType == Notes.TYPE_NOTE) { + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, false, -1); + } + } + } else { + // 更新已存在的笔记 + if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { + Log.e(TAG, "没有这样的笔记"); + throw new IllegalStateException("尝试使用无效ID更新笔记"); + } + + if (mDiffNoteValues.size() > 0) { + mVersion++; + + // 构造更新条件和参数 + int result = 0; + if (!validateVersion) { + result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + + NoteColumns.ID + "=?)", new String[] { + String.valueOf(mId) + }); + } else { + result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", + new String[] { + String.valueOf(mId), String.valueOf(mVersion) + }); + } + + if (result == 0) { + Log.w(TAG, "没有更新。可能是用户在同步时更新了笔记"); + } + } + + // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表 + if (mType == Notes.TYPE_NOTE) { + for (SqlData sqlData : mDataList) { + sqlData.commit(mId, validateVersion, mVersion); + } + } + } + + // 刷新本地信息 + loadFromCursor(mId); + if (mType == Notes.TYPE_NOTE) + loadDataContent(); + + // 清空差异值、重置创建标志 + mDiffNoteValues.clear(); + mIsCreate = false; + } From 2c6f4593272c594165c9fbc772157ef1113970f4 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:51:07 +0800 Subject: [PATCH 04/12] Update Task.java --- src/gtask/data/Task.java | 225 ++++++++++++++++++++++++++------------- 1 file changed, 150 insertions(+), 75 deletions(-) diff --git a/src/gtask/data/Task.java b/src/gtask/data/Task.java index b9730ae..75922b7 100644 --- a/src/gtask/data/Task.java +++ b/src/gtask/data/Task.java @@ -24,170 +24,220 @@ public class Task extends Node { mMetaInfo = null; } + /** + * 生成创建任务操作的 JSON 对象 + * + * @param actionId 操作的唯一标识符 + * @return 包含创建任务操作信息的 JSON 对象 + * @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常 + */ public JSONObject getCreateAction(int actionId) { JSONObject js = new JSONObject(); - + try { - // action_type + // 设置操作类型为创建任务 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); - - // action_id + + // 设置操作的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - - // index + + // 设置任务在父任务中的索引 js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); - - // entity_delta + + // 设置实体的变化信息 JSONObject entity = new JSONObject(); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, GTaskStringUtils.GTASK_JSON_TYPE_TASK); + + // 如果任务有附加注释，则设置注释信息 if (getNotes() != null) { entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); } js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); - - // parent_id - if (mParent!= null) { - js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); + + // 设置父任务的唯一标识符 + if (mParent != null) { + js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); } - - // dest_parent_type + + // 设置目标父任务的类型为 GROUP js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, GTaskStringUtils.GTASK_JSON_TYPE_GROUP); - - // list_id - if (mParent!= null) { - js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); + + // 设置任务所属列表的唯一标识符 + if (mParent != null) { + js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); } - - // prior_sibling_id + + // 设置相邻任务的唯一标识符，用于确定任务在兄弟任务中的位置 if (mPriorSibling != null) { js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); } - + } catch (JSONException e) { + // 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate task-create jsonobject"); + throw new ActionFailureException("生成任务创建 JSON 对象失败"); } - + return js; } - + + /** + * 生成更新任务操作的 JSON 对象 + * + * @param actionId 操作的唯一标识符 + * @return 包含更新任务操作信息的 JSON 对象 + * @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常 + */ public JSONObject getUpdateAction(int actionId) { JSONObject js = new JSONObject(); - + try { - // action_type + // 设置操作类型为更新任务 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); - - // action_id + + // 设置操作的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - - // id + + // 设置任务的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); - - // entity_delta + + // 设置实体的变化信息 JSONObject entity = new JSONObject(); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + + // 如果任务有附加注释，则设置注释信息 if (getNotes() != null) { entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); } + + // 设置任务是否被删除 entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); - + } catch (JSONException e) { + // 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate task-update jsonobject"); + throw new ActionFailureException("生成任务更新 JSON 对象失败"); } - + return js; } + + /** + * 根据远程 JSON 对象设置任务内容 + * + * @param js 包含任务内容信息的远程 JSON 对象 + * @throws ActionFailureException 如果解析 JSON 对象时发生异常，则抛出 ActionFailureException 异常 + */ public void setContentByRemoteJSON(JSONObject js) { if (js != null) { try { - // id + // 设置任务的唯一标识符 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); } - - // last_modified + + // 设置任务的最后修改时间 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); } - - // name + + // 设置任务的名称 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); } - - // notes + + // 设置任务的注释 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); } - - // deleted + + // 设置任务是否被删除 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); } - - // completed + + // 设置任务是否已完成 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); } } catch (JSONException e) { + // 如果解析 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to get task content from jsonobject"); + throw new ActionFailureException("从 JSON 对象获取任务内容失败"); } } } + - public void setContentByLocalJSON(JSONObject js) { // metadata ʵʩ + /** + * 根据本地 JSON 对象设置任务内容 + * + * @param js 包含任务内容信息的本地 JSON 对象 + */ + public void setContentByLocalJSON(JSONObject js) { + // 检查 JSON 对象是否有效，以及是否包含必要的信息 if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) || !js.has(GTaskStringUtils.META_HEAD_DATA)) { - Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + Log.w(TAG, "setContentByLocalJSON: 没有可用的信息"); } - + try { + // 获取任务的元数据 JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); - + + // 检查任务类型是否为 Notes.TYPE_NOTE if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { - Log.e(TAG, "invalid type"); + Log.e(TAG, "无效的类型"); return; } - + + // 遍历数据数组，查找包含 MIME_TYPE 为 DataConstants.NOTE 的数据项 for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { + // 将数据项的内容设置为任务的名称 setName(data.getString(DataColumns.CONTENT)); break; } } - + } catch (JSONException e) { + // 如果解析 JSON 对象时发生异常，则记录错误日志 Log.e(TAG, e.toString()); e.printStackTrace(); } } + + /** + * 从任务内容生成本地 JSON 对象 + * + * @return 包含任务元数据的本地 JSON 对象 + */ public JSONObject getLocalJSONFromContent() { String name = getName(); try { + // 如果任务的元数据为空，表示是从 web 创建的新任务 if (mMetaInfo == null) { - // new task created from web + // 新任务为空，记录警告日志并返回 null if (name == null) { - Log.w(TAG, "the note seems to be an empty one"); + Log.w(TAG, "任务似乎是一个空任务"); return null; } - + + // 构建 JSON 对象包含任务元数据和数据数组 JSONObject js = new JSONObject(); JSONObject note = new JSONObject(); JSONArray dataArray = new JSONArray(); @@ -199,10 +249,10 @@ public class Task extends Node { js.put(GTaskStringUtils.META_HEAD_NOTE, note); return js; } else { - // synced task + // 如果是已同步的任务，更新数据数组中 MIME_TYPE 为 DataConstants.NOTE 的数据项的内容 JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); - + for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { @@ -210,80 +260,105 @@ public class Task extends Node { break; } } - + + // 更新任务类型为 Notes.TYPE_NOTE，并返回元数据 JSON 对象 note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); return mMetaInfo; } } catch (JSONException e) { + // 如果生成 JSON 对象时发生异常，则记录错误日志并返回 null Log.e(TAG, e.toString()); e.printStackTrace(); return null; } } + + /** + * 根据 MetaData 对象设置元数据信息 + * + * @param metaData 包含元数据信息的 MetaData 对象 + */ public void setMetaInfo(MetaData metaData) { + // 检查 MetaData 对象是否有效，且是否包含注释信息 if (metaData != null && metaData.getNotes() != null) { try { + // 将注释信息转换为 JSON 对象并赋值给 mMetaInfo mMetaInfo = new JSONObject(metaData.getNotes()); } catch (JSONException e) { + // 如果转换为 JSON 对象时发生异常，则记录警告日志并将 mMetaInfo 置为 null Log.w(TAG, e.toString()); mMetaInfo = null; } } } + + /** + * 获取同步操作类型 + * + * @param c 包含本地数据库信息的 Cursor 对象 + * @return 同步操作类型，可能的值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_REMOTE、 + * SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_CONFLICT 和 SYNC_ACTION_ERROR + */ public int getSyncAction(Cursor c) { try { JSONObject noteInfo = null; + + // 检查元数据是否存在且包含注释信息 if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); } - + + // 如果注释信息不存在，记录警告日志并返回 SYNC_ACTION_UPDATE_REMOTE if (noteInfo == null) { - Log.w(TAG, "it seems that note meta has been deleted"); + Log.w(TAG, "似乎已删除注释元数据"); return SYNC_ACTION_UPDATE_REMOTE; } - + + // 如果注释信息中不包含 NoteColumns.ID，记录警告日志并返回 SYNC_ACTION_UPDATE_LOCAL if (!noteInfo.has(NoteColumns.ID)) { - Log.w(TAG, "remote note id seems to be deleted"); + Log.w(TAG, "远程注释 ID 似乎已删除"); return SYNC_ACTION_UPDATE_LOCAL; } - - // validate the note id now + + // 验证注释 ID 是否与本地数据库中的 ID 匹配 if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { - Log.w(TAG, "note id doesn't match"); + Log.w(TAG, "注释 ID 不匹配"); return SYNC_ACTION_UPDATE_LOCAL; } - + if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + // 本地没有更新 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side + // 两边都没有更新 return SYNC_ACTION_NONE; } else { - // apply remote to local + // 应用远程更新到本地 return SYNC_ACTION_UPDATE_LOCAL; } } else { - // validate gtask id + // 验证 gtask id if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { - Log.e(TAG, "gtask id doesn't match"); + Log.e(TAG, "gtask ID 不匹配"); return SYNC_ACTION_ERROR; } if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // local modification only + // 仅本地修改 return SYNC_ACTION_UPDATE_REMOTE; } else { return SYNC_ACTION_UPDATE_CONFLICT; } } } catch (Exception e) { + // 如果发生异常，记录错误日志并返回 SYNC_ACTION_ERROR Log.e(TAG, e.toString()); e.printStackTrace(); } - + return SYNC_ACTION_ERROR; } + public boolean isWorthSaving() { return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) From 05df45cbfc2a745a43dbb81f838d14efddbb5fd3 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:56:39 +0800 Subject: [PATCH 05/12] Update TaskList.java --- src/gtask/data/TaskList.java | 176 ++++++++++++++++++++++++----------- 1 file changed, 120 insertions(+), 56 deletions(-) diff --git a/src/gtask/data/TaskList.java b/src/gtask/data/TaskList.java index 15a6bbc..7234dfd 100644 --- a/src/gtask/data/TaskList.java +++ b/src/gtask/data/TaskList.java @@ -13,186 +13,250 @@ public class TaskList extends Node { mIndex = 1; } - /* (non-Javadoc) - * @see net.micode.notes.gtask.data.Node#getCreateAction(int) - * 生成并返回一个包含了一定数据的JSONObject实体 + /** + * 获取创建任务列表操作的 JSON 对象 + * + * @param actionId 操作的唯一标识符 + * @return 包含创建任务列表操作信息的 JSON 对象 + * @throws ActionFailureException 如果生成 JSON 对象过程中发生异常 */ - public JSONObject getCreateAction(int actionId) { + public JSONObject getCreateAction(int actionId) throws ActionFailureException { + // 创建空的 JSON 对象 JSONObject js = new JSONObject(); - + try { - // action_type + // 设置操作类型为创建任务列表 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); - - // action_id + + // 设置操作的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - - // index + + // 设置任务列表的索引 js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); - - // entity_delta - JSONObject entity = new JSONObject();//entity实体 + + // 创建实体信息的 JSON 对象 + JSONObject entity = new JSONObject(); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, GTaskStringUtils.GTASK_JSON_TYPE_GROUP); + + // 将实体信息添加到操作中 js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); - + } catch (JSONException e) { + // 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-create jsonobject"); + throw new ActionFailureException("生成任务列表创建操作的 JSON 对象失败"); } - + return js; } + - /* (non-Javadoc) - * @see net.micode.notes.gtask.data.Node#getUpdateAction(int) - * 生成并返回一个包含了一定数据的JSONObject实体 + /** + * 获取更新任务列表操作的 JSON 对象 + * + * @param actionId 操作的唯一标识符 + * @return 包含更新任务列表操作信息的 JSON 对象 + * @throws ActionFailureException 如果生成 JSON 对象过程中发生异常 */ - public JSONObject getUpdateAction(int actionId) { + public JSONObject getUpdateAction(int actionId) throws ActionFailureException { + // 创建空的 JSON 对象 JSONObject js = new JSONObject(); - + try { - // action_type + // 设置操作类型为更新任务列表 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); - - // action_id + + // 设置操作的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - - // id + + // 设置任务列表的唯一标识符 js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); - - // entity_delta + + // 创建实体信息的 JSON 对象 JSONObject entity = new JSONObject(); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); + + // 将实体信息添加到操作中 js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); - + } catch (JSONException e) { + // 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-update jsonobject"); + throw new ActionFailureException("生成任务列表更新操作的 JSON 对象失败"); } - + return js; } + - public void setContentByRemoteJSON(JSONObject js) { + /** + * 通过远程 JSON 对象设置任务列表内容 + * + * @param js 包含任务列表信息的 JSON 对象 + * @throws ActionFailureException 如果在设置任务列表内容过程中发生异常 + */ + public void setContentByRemoteJSON(JSONObject js) throws ActionFailureException { if (js != null) { try { - // id + // 设置任务列表的唯一标识符 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); } - - // last_modified + + // 设置任务列表的最后修改时间 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); } - - // name + + // 设置任务列表的名称 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); } - + } catch (JSONException e) { + // 如果在设置任务列表内容过程中发生异常，记录错误日志并抛出 ActionFailureException 异常 Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to get tasklist content from jsonobject"); + throw new ActionFailureException("从 JSON 对象获取任务列表内容失败"); } } } + + /** + * 通过本地 JSON 对象设置任务列表内容 + * + * @param js 包含任务列表信息的本地 JSON 对象 + */ public void setContentByLocalJSON(JSONObject js) { if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { - Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + // 如果 JSON 对象为空或不包含任务列表信息，记录警告日志 + Log.w(TAG, "setContentByLocalJSON: 没有可用的信息"); } - + try { + // 获取任务列表的元数据信息 JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); - + if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 如果是文件夹类型的任务列表 String name = folder.getString(NoteColumns.SNIPPET); + // 设置任务列表名称为 MIUI 文件夹前缀加上文件夹的片段信息 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + // 如果是系统文件夹类型的任务列表 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) + // 根文件夹 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) - setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX - + GTaskStringUtils.FOLDER_CALL_NOTE); + // 通话记录文件夹 + setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE); else - Log.e(TAG, "invalid system folder"); + // 无效的系统文件夹 + Log.e(TAG, "无效的系统文件夹"); } else { - Log.e(TAG, "error type"); + // 错误的类型 + Log.e(TAG, "错误的类型"); } } catch (JSONException e) { + // 如果在设置任务列表内容的过程中发生异常，记录错误日志 Log.e(TAG, e.toString()); e.printStackTrace(); } } + + /** + * 根据任务列表内容生成本地 JSON 对象 + * + * @return 包含任务列表信息的本地 JSON 对象 + */ public JSONObject getLocalJSONFromContent() { try { + // 创建 JSON 对象用于存储任务列表信息 JSONObject js = new JSONObject(); + // 创建 JSON 对象用于存储任务列表元数据 JSONObject folder = new JSONObject(); - + + // 获取任务列表名称 String folderName = getName(); + // 如果名称以 MIUI 文件夹前缀开头，去掉前缀部分 if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(), folderName.length()); + + // 设置任务列表元数据的片段信息和类型 folder.put(NoteColumns.SNIPPET, folderName); if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT) || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE)) + // 如果是默认文件夹或通话记录文件夹，设置为系统文件夹类型 folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); else + // 否则设置为文件夹类型 folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); - + + // 将任务列表元数据放入 JSON 对象 js.put(GTaskStringUtils.META_HEAD_NOTE, folder); - + return js; } catch (JSONException e) { + // 如果在生成本地 JSON 对象的过程中发生异常，记录错误日志 Log.e(TAG, e.toString()); e.printStackTrace(); return null; } } + + /** + * 获取同步操作类型 + * + * @param c 游标对象，包含本地数据库中的任务信息 + * @return 同步操作类型，可能的取值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、 + * SYNC_ACTION_UPDATE_REMOTE 和 SYNC_ACTION_ERROR + */ public int getSyncAction(Cursor c) { try { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + // 本地无更新 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side + // 本地和远程都无更新 return SYNC_ACTION_NONE; } else { - // apply remote to local + // 将远程更新应用到本地 return SYNC_ACTION_UPDATE_LOCAL; } } else { - // validate gtask id + // 验证 gtask id if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { Log.e(TAG, "gtask id doesn't match"); return SYNC_ACTION_ERROR; } if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // local modification only + // 仅有本地修改 return SYNC_ACTION_UPDATE_REMOTE; } else { - // for folder conflicts, just apply local modification + // 对于文件夹冲突，仅应用本地修改 return SYNC_ACTION_UPDATE_REMOTE; } } } catch (Exception e) { + // 如果在获取同步操作类型的过程中发生异常，记录错误日志 Log.e(TAG, e.toString()); e.printStackTrace(); } - + return SYNC_ACTION_ERROR; } + /** * @return From cac39302639bf2146bddae85ce1a2d65722214d9 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 16:58:47 +0800 Subject: [PATCH 06/12] Update SqlData.java --- src/gtask/data/SqlData.java | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/src/gtask/data/SqlData.java b/src/gtask/data/SqlData.java index b03b87f..bfd044b 100644 --- a/src/gtask/data/SqlData.java +++ b/src/gtask/data/SqlData.java @@ -154,35 +154,45 @@ public class SqlData { return js; } - /* - * 功能描述：commit函数用于把当前造作所做的修改保存到数据库 - */ + /** + * 提交数据变更到数据库 + * + * @param noteId 笔记 ID，用于关联数据 + * @param validateVersion 是否验证版本信息 + * @param version 笔记版本号 + */ public void commit(long noteId, boolean validateVersion, long version) { - + // 如果是新创建的数据 if (mIsCreate) { + // 如果数据 ID 无效且差异数据集合包含数据 ID，则移除数据 ID if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { mDiffDataValues.remove(DataColumns.ID); } - + + // 设置笔记 ID，将差异数据插入到数据表 mDiffDataValues.put(DataColumns.NOTE_ID, noteId); Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); try { + // 从 URI 中获取插入的数据 ID mDataId = Long.valueOf(uri.getPathSegments().get(1)); } catch (NumberFormatException e) { Log.e(TAG, "Get note id error :" + e.toString()); throw new ActionFailureException("create note failed"); } } else { + // 如果有数据更新 if (mDiffDataValues.size() > 0) { int result = 0; if (!validateVersion) { + // 如果不需要验证版本，直接更新数据表 result = mContentResolver.update(ContentUris.withAppendedId( Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); } else { + // 需要验证版本，构造 SQL 语句进行更新 result = mContentResolver.update(ContentUris.withAppendedId( Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE - + " WHERE " + NoteColumns.VERSION + "=?)", new String[] { + + " WHERE " + NoteColumns.VERSION + "=?)", new String[]{ String.valueOf(noteId), String.valueOf(version) }); } @@ -191,10 +201,12 @@ public class SqlData { } } } - + + // 清空差异数据集合和创建标志 mDiffDataValues.clear(); mIsCreate = false; } + /* * 功能描述：获取当前id From cebe76f3ecdf0ac2876e92ed65f91323977bc9ff Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:00:21 +0800 Subject: [PATCH 07/12] Update SqlData.java --- src/gtask/data/SqlData.java | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/src/gtask/data/SqlData.java b/src/gtask/data/SqlData.java index bfd044b..05cc195 100644 --- a/src/gtask/data/SqlData.java +++ b/src/gtask/data/SqlData.java @@ -98,42 +98,50 @@ public class SqlData { } - /* - * 功能描述：设置用于共享的数据，并提供异常抛出与处理机制 - */ + /** + * 设置用于共享的数据，并提供异常抛出与处理机制 + * + * @param js 传入的 JSONObject 对象 + * @throws JSONException JSON 解析异常 + */ public void setContent(JSONObject js) throws JSONException { - //如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID + // 如果传入的 JSONObject 对象中有 DataColumns.ID 这一项，则设置，否则设为 INVALID_ID long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; if (mIsCreate || mDataId != dataId) { mDiffDataValues.put(DataColumns.ID, dataId); } mDataId = dataId; - + + // 获取数据 MIME 类型，默认为 DataConstants.NOTE String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) : DataConstants.NOTE; if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); } mDataMimeType = dataMimeType; - + + // 获取数据内容，默认为空字符串 String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; if (mIsCreate || !mDataContent.equals(dataContent)) { mDiffDataValues.put(DataColumns.CONTENT, dataContent); } mDataContent = dataContent; - + + // 获取数据附加内容 1，默认为 0 long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; if (mIsCreate || mDataContentData1 != dataContentData1) { mDiffDataValues.put(DataColumns.DATA1, dataContentData1); } mDataContentData1 = dataContentData1; - + + // 获取数据附加内容 3，默认为空字符串 String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { mDiffDataValues.put(DataColumns.DATA3, dataContentData3); } mDataContentData3 = dataContentData3; } + /* From a593b50a51ac1d6ab24535b3b301c5a21d0621f7 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:02:03 +0800 Subject: [PATCH 08/12] Update ActionFailureException.java --- src/gtask/exception/ActionFailureException.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/gtask/exception/ActionFailureException.java b/src/gtask/exception/ActionFailureException.java index 72c4cda..114bf15 100644 --- a/src/gtask/exception/ActionFailureException.java +++ b/src/gtask/exception/ActionFailureException.java @@ -11,7 +11,6 @@ public class ActionFailureException extends RuntimeException { /* * serialVersionUID相当于java类的身份证。主要用于版本控制。 * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。 - * Made By Cuican */ public ActionFailureException() { @@ -22,7 +21,6 @@ public class ActionFailureException extends RuntimeException { * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。 * 怎么去引用里面的父类对象呢？使用super来引用 * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString) - * Made By Cuican */ public ActionFailureException(String paramString) { super(paramString); From 90b99f11e0452a57f51121daa2743ee77d59fb95 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:02:35 +0800 Subject: [PATCH 09/12] Update NetworkFailureException.java --- src/gtask/exception/NetworkFailureException.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/gtask/exception/NetworkFailureException.java b/src/gtask/exception/NetworkFailureException.java index e12b670..798675d 100644 --- a/src/gtask/exception/NetworkFailureException.java +++ b/src/gtask/exception/NetworkFailureException.java @@ -10,7 +10,6 @@ public class NetworkFailureException extends Exception { /* * serialVersionUID相当于java类的身份证。主要用于版本控制。 * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。 - * Made By Cuican */ public NetworkFailureException() { @@ -22,7 +21,6 @@ public class NetworkFailureException extends Exception { * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。 * 怎么去引用里面的父类对象呢？使用super来引用 * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString) - * Made By Cuican */ public NetworkFailureException(String paramString) { super(paramString); From dc5f7f09c23cdf66be459d7bd1e5b5f5df2889c9 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:05:07 +0800 Subject: [PATCH 10/12] Update GTaskASyncTask.java --- src/gtask/remote/GTaskASyncTask.java | 38 ++++++++++++++++++---------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/src/gtask/remote/GTaskASyncTask.java b/src/gtask/remote/GTaskASyncTask.java index b1febfc..127bada 100644 --- a/src/gtask/remote/GTaskASyncTask.java +++ b/src/gtask/remote/GTaskASyncTask.java @@ -25,31 +25,43 @@ import net.micode.notes.ui.NotesPreferenceActivity; public class GTaskASyncTask extends AsyncTask { + /* + * 通知的ID，用于同步通知 + */ private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; - + + /** + * 完成监听器接口，用于在任务完成时回调 + */ public interface OnCompleteListener { void onComplete(); } - - private Context mContext; - - private NotificationManager mNotifiManager; - - private GTaskManager mTaskManager; - - private OnCompleteListener mOnCompleteListener; - + + private Context mContext; // 上下文对象 + private NotificationManager mNotifiManager; // 通知管理器 + private GTaskManager mTaskManager; // GTask管理器 + private OnCompleteListener mOnCompleteListener; // 完成监听器 + + /** + * 构造函数，初始化异步任务 + * + * @param context 上下文对象 + * @param listener 完成监听器 + */ public GTaskASyncTask(Context context, OnCompleteListener listener) { mContext = context; mOnCompleteListener = listener; - mNotifiManager = (NotificationManager) mContext - .getSystemService(Context.NOTIFICATION_SERVICE); + mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); mTaskManager = GTaskManager.getInstance(); } - + + /** + * 取消同步任务 + */ public void cancelSync() { mTaskManager.cancelSync(); } + public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值 publishProgress(new String[] { From 1cdcef10596aec8c306c88e6d73bd00f52284852 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:14:17 +0800 Subject: [PATCH 11/12] Update GTaskManager.java --- src/gtask/remote/GTaskManager.java | 118 +++++++++++++++-------------- 1 file changed, 63 insertions(+), 55 deletions(-) diff --git a/src/gtask/remote/GTaskManager.java b/src/gtask/remote/GTaskManager.java index 9cebd81..ae39538 100644 --- a/src/gtask/remote/GTaskManager.java +++ b/src/gtask/remote/GTaskManager.java @@ -38,7 +38,6 @@ public class GTaskManager { /** * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 * 功能：类初始化函数 - * @author TTS * @return GtaskManger */ public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized @@ -50,7 +49,6 @@ public class GTaskManager { /** * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 - * @author TTS * @param activity */ public synchronized void setActivityContext(Activity activity) { @@ -61,7 +59,6 @@ public class GTaskManager { /** * 核心函数 * 功能：实现了本地同步操作和远端同步操作 - * @author TTS * @param context-----获取上下文 * @param asyncTask-------用于同步的异步操作类 * @return int @@ -126,7 +123,6 @@ public class GTaskManager { /** *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。 *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap - *@author TTS *@exception NetworkFailureException *@return void */ @@ -320,22 +316,20 @@ public class GTaskManager { } - /** - * 功能： - * @author TTS - * @throws NetworkFailureException + /* + * 同步文件夹的方法，抛出网络异常 */ private void syncFolder() throws NetworkFailureException { Cursor c = null; String gid; Node node; int syncType; - + if (mCancelled) { return; } - - // for root folder + + // 同步根目录 try { c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null); @@ -347,7 +341,7 @@ public class GTaskManager { mGTaskHashMap.remove(gid); mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); - // for system folder, only update remote name if necessary + // 仅在必要时更新远程名称 if (!node.getName().equals( GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); @@ -363,12 +357,12 @@ public class GTaskManager { c = null; } } - - // for call-note folder + + // 同步通话记录文件夹 try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", new String[] { - String.valueOf(Notes.ID_CALL_RECORD_FOLDER) + String.valueOf(Notes.ID_CALL_RECORD_FOLDER) }, null); if (c != null) { if (c.moveToNext()) { @@ -378,8 +372,7 @@ public class GTaskManager { mGTaskHashMap.remove(gid); mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER); mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid); - // for system folder, only update remote name if - // necessary + // 仅在必要时更新远程名称 if (!node.getName().equals( GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) @@ -397,8 +390,8 @@ public class GTaskManager { c = null; } } - - // for local existing folders + + // 同步本地已存在的文件夹 try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(type=? AND parent_id<>?)", new String[] { @@ -415,10 +408,10 @@ public class GTaskManager { syncType = node.getSyncAction(c); } else { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { - // local add + // 本地添加 syncType = Node.SYNC_ACTION_ADD_REMOTE; } else { - // remote delete + // 远程删除 syncType = Node.SYNC_ACTION_DEL_LOCAL; } } @@ -433,8 +426,8 @@ public class GTaskManager { c = null; } } - - // for remote add folders + + // 同步远程添加的文件夹 Iterator> iter = mGTaskListHashMap.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = iter.next(); @@ -445,33 +438,38 @@ public class GTaskManager { doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); } } - + if (!mCancelled) GTaskClient.getInstance().commitUpdate(); } - + /** * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode - * @author TTS * @param syncType * @param node * @param c * @throws NetworkFailureException */ + /* + * 执行内容同步操作 + */ private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException { if (mCancelled) { return; } - + MetaData meta; switch (syncType) { case Node.SYNC_ACTION_ADD_LOCAL: + // 添加本地节点 addLocalNode(node); break; case Node.SYNC_ACTION_ADD_REMOTE: + // 添加远程节点 addRemoteNode(node, c); break; case Node.SYNC_ACTION_DEL_LOCAL: + // 获取本地删除节点的元数据，然后删除 meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); if (meta != null) { GTaskClient.getInstance().deleteNode(meta); @@ -479,6 +477,7 @@ public class GTaskManager { mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); break; case Node.SYNC_ACTION_DEL_REMOTE: + // 获取远程删除节点的元数据，然后删除节点 meta = mMetaHashMap.get(node.getGid()); if (meta != null) { GTaskClient.getInstance().deleteNode(meta); @@ -486,63 +485,77 @@ public class GTaskManager { GTaskClient.getInstance().deleteNode(node); break; case Node.SYNC_ACTION_UPDATE_LOCAL: + // 更新本地节点 updateLocalNode(node, c); break; case Node.SYNC_ACTION_UPDATE_REMOTE: + // 更新远程节点 updateRemoteNode(node, c); break; case Node.SYNC_ACTION_UPDATE_CONFLICT: - // merging both modifications maybe a good idea - // right now just use local update simply + // 合并两者的修改，目前仅简单使用本地更新 updateRemoteNode(node, c); break; case Node.SYNC_ACTION_NONE: + // 无动作 break; case Node.SYNC_ACTION_ERROR: default: - throw new ActionFailureException("unkown sync action type"); + // 未知的同步操作类型，抛出异常 + throw new ActionFailureException("unknown sync action type"); } } + - /** - * 功能：本地增加Node - * @author TTS - * @param node - * @throws NetworkFailureException + + /* + * 功能描述：添加本地节点 + * 参数：node - 节点对象 + * 返回：无 + * 异常：NetworkFailureException - 网络异常 */ private void addLocalNode(Node node) throws NetworkFailureException { if (mCancelled) { return; } - + SqlNote sqlNote; + + // 如果节点为任务列表 if (node instanceof TaskList) { if (node.getName().equals( GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { + // 根据任务列表的名称判断是否为默认文件夹，创建对应的 SqlNote 对象 sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); } else if (node.getName().equals( GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { + // 根据任务列表的名称判断是否为通话记录文件夹，创建对应的 SqlNote 对象 sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); } else { + // 其他情况创建普通任务列表对应的 SqlNote 对象 sqlNote = new SqlNote(mContext); sqlNote.setContent(node.getLocalJSONFromContent()); sqlNote.setParentId(Notes.ID_ROOT_FOLDER); } } else { + // 如果节点为任务 sqlNote = new SqlNote(mContext); JSONObject js = node.getLocalJSONFromContent(); + try { + // 处理 META_HEAD_NOTE 中的 ID，确保本地数据库中不存在该 ID if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); if (note.has(NoteColumns.ID)) { long id = note.getLong(NoteColumns.ID); if (DataUtils.existInNoteDatabase(mContentResolver, id)) { - // the id is not available, have to create a new one + // 如果 ID 在本地数据库中存在，则移除该 ID，创建新的任务 ID note.remove(NoteColumns.ID); } } } - + + // 处理 META_HEAD_DATA 中的 ID，确保本地数据库中不存在该 ID if (js.has(GTaskStringUtils.META_HEAD_DATA)) { JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); for (int i = 0; i < dataArray.length(); i++) { @@ -550,20 +563,21 @@ public class GTaskManager { if (data.has(DataColumns.ID)) { long dataId = data.getLong(DataColumns.ID); if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { - // the data id is not available, have to create - // a new one + // 如果 ID 在本地数据库中存在，则移除该 ID，创建新的数据 ID data.remove(DataColumns.ID); } } } - } } catch (JSONException e) { Log.w(TAG, e.toString()); e.printStackTrace(); } + + // 设置 SqlNote 对象的内容为节点的本地 JSON 表示 sqlNote.setContent(js); - + + // 获取节点的父节点的本地 ID，用于设置 SqlNote 对象的父 ID Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); if (parentId == null) { Log.e(TAG, "cannot find task's parent id locally"); @@ -571,22 +585,22 @@ public class GTaskManager { } sqlNote.setParentId(parentId.longValue()); } - - // create the local node + + // 设置 SqlNote 对象的 GTask ID，并提交到本地数据库 sqlNote.setGtaskId(node.getGid()); sqlNote.commit(false); - - // update gid-nid mapping + + // 更新 GTask ID 到本地 ID 的映射关系 mGidToNid.put(node.getGid(), sqlNote.getId()); mNidToGid.put(sqlNote.getId(), node.getGid()); - - // update meta + + // 更新远程 Meta 信息 updateRemoteMeta(node.getGid(), sqlNote); } + /** * 功能：update本地node - * @author TTS * @param node * ----同步操作的基础数据类型 * @param c @@ -619,7 +633,6 @@ public class GTaskManager { /** * 功能：远程增加Node * 需要updateRemoteMeta - * @author TTS * @param node * ----同步操作的基础数据类型 * @param c @@ -703,7 +716,6 @@ public class GTaskManager { /** * 功能：更新远端的Node，包含meta更新(updateRemoteMeta) - * @author TTS * @param node * ----同步操作的基础数据类型 * @param c @@ -755,7 +767,6 @@ public class GTaskManager { /** * 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。 - * @author TTS * @param gid * ---GoogleID为String类型 * @param sqlNote @@ -780,7 +791,6 @@ public class GTaskManager { /** * 功能：刷新本地，给sync的ID对应上最后更改过的对象 - * @author TTS * @return void * @throws NetworkFailureException */ @@ -830,7 +840,6 @@ public class GTaskManager { /** * 功能：获取同步账号,mAccount.name - * @author TTS * @return String */ public String getSyncAccount() { @@ -839,7 +848,6 @@ public class GTaskManager { /** * 功能：取消同步，置mCancelled为true - * @author TTS */ public void cancelSync() { mCancelled = true; From 020d0e123781fb849a3a9331320b58e3a8e7c2e4 Mon Sep 17 00:00:00 2001 From: ph2y8awtk <534528244@qq.com> Date: Fri, 15 Dec 2023 17:22:09 +0800 Subject: [PATCH 12/12] Update GTaskSyncService.java --- src/gtask/remote/GTaskSyncService.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gtask/remote/GTaskSyncService.java b/src/gtask/remote/GTaskSyncService.java index 1e0fede..61fa8db 100644 --- a/src/gtask/remote/GTaskSyncService.java +++ b/src/gtask/remote/GTaskSyncService.java @@ -91,7 +91,7 @@ public class GTaskSyncService extends Service { } } - public IBinder onBind(Intent intent) { //不知道干吗用的 + public IBinder onBind(Intent intent) { return null; }